# 1 "../../target-i386/translate.c"
# 1 "/root/qemu-linaro-0.13.50-2011.02-0~rc2/system-build/x86_64-softmmu//"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "../../target-i386/translate.c"
# 19 "../../target-i386/translate.c"
# 1 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include/stdarg.h" 1 3 4
# 40 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 102 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include/stdarg.h" 3 4
typedef __gnuc_va_list va_list;
# 20 "../../target-i386/translate.c" 2
# 1 "/usr/include/stdlib.h" 1 3 4
# 25 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 322 "/usr/include/features.h" 3 4
# 1 "/usr/include/bits/predefs.h" 1 3 4
# 323 "/usr/include/features.h" 2 3 4
# 355 "/usr/include/features.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 353 "/usr/include/sys/cdefs.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 354 "/usr/include/sys/cdefs.h" 2 3 4
# 356 "/usr/include/features.h" 2 3 4
# 387 "/usr/include/features.h" 3 4
# 1 "/usr/include/gnu/stubs.h" 1 3 4
# 388 "/usr/include/features.h" 2 3 4
# 26 "/usr/include/stdlib.h" 2 3 4







# 1 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include/stddef.h" 1 3 4
# 211 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include/stddef.h" 3 4
typedef unsigned int size_t;
# 323 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include/stddef.h" 3 4
typedef unsigned int wchar_t;
# 34 "/usr/include/stdlib.h" 2 3 4








# 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
# 61 "/usr/include/endian.h" 3 4
# 1 "/usr/include/bits/byteswap.h" 1 3 4
# 62 "/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
# 68 "/usr/include/stdlib.h" 3 4
typedef union
  {
    union wait *__uptr;
    int *__iptr;
  } __WAIT_STATUS __attribute__ ((__transparent_union__));
# 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) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));




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

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

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





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





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





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

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





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

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




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

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





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

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

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

  struct __locale_data *__locales[13];


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


  const char *__names[13];
} *__locale_t;


typedef __locale_t locale_t;
# 237 "/usr/include/stdlib.h" 2 3 4



extern long int strtol_l (__const char *__restrict __nptr,
     char **__restrict __endptr, int __base,
     __locale_t __loc) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 4))) __attribute__ ((__warn_unused_result__));

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

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

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

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

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

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





extern __inline double
__attribute__ ((__nothrow__)) atof (__const char *__nptr)
{
  return strtod (__nptr, (char **) ((void *)0));
}
extern __inline int
__attribute__ ((__nothrow__)) atoi (__const char *__nptr)
{
  return (int) strtol (__nptr, (char **) ((void *)0), 10);
}
extern __inline long int
__attribute__ ((__nothrow__)) atol (__const char *__nptr)
{
  return strtol (__nptr, (char **) ((void *)0), 10);
}




__extension__ extern __inline long long int
__attribute__ ((__nothrow__)) atoll (__const char *__nptr)
{
  return strtoll (__nptr, (char **) ((void *)0), 10);
}

# 311 "/usr/include/stdlib.h" 3 4
extern char *l64a (long int __n) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));


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




# 1 "/usr/include/sys/types.h" 1 3 4
# 28 "/usr/include/sys/types.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


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;
# 131 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/typesizes.h" 1 3 4
# 132 "/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 void * __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;
# 31 "/usr/include/sys/types.h" 2 3 4



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




typedef __loff_t loff_t;





typedef __ino64_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 __off64_t off_t;




typedef __off64_t off64_t;




typedef __pid_t pid_t;





typedef __id_t id_t;




typedef __ssize_t ssize_t;





typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;





typedef __key_t key_t;
# 133 "/usr/include/sys/types.h" 3 4
# 1 "/usr/include/time.h" 1 3 4
# 58 "/usr/include/time.h" 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;
# 134 "/usr/include/sys/types.h" 2 3 4



typedef __useconds_t useconds_t;



typedef __suseconds_t suseconds_t;





# 1 "/usr/lib/gcc/arm-linux-gnueabi/4.5.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;
# 195 "/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__)));
# 220 "/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
# 24 "/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/time.h" 1 3 4
# 120 "/usr/include/time.h" 3 4
struct timespec
  {
    __time_t tv_sec;
    long int tv_nsec;
  };
# 45 "/usr/include/sys/select.h" 2 3 4

# 1 "/usr/include/bits/time.h" 1 3 4
# 75 "/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 * (int) sizeof (__fd_mask))];





  } fd_set;






typedef __fd_mask fd_mask;
# 99 "/usr/include/sys/select.h" 3 4

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



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


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


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

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

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





typedef __blksize_t blksize_t;
# 249 "/usr/include/sys/types.h" 3 4
typedef __blkcnt64_t blkcnt_t;



typedef __fsblkcnt64_t fsblkcnt_t;



typedef __fsfilcnt64_t fsfilcnt_t;





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





# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
# 38 "/usr/include/bits/pthreadtypes.h" 3 4
typedef unsigned long int pthread_t;


typedef union
{
  char __size[36];
  long int __align;
} pthread_attr_t;


typedef struct __pthread_internal_slist
{
  struct __pthread_internal_slist *__next;
} __pthread_slist_t;




typedef union
{
  struct __pthread_mutex_s
  {
    int __lock;
    unsigned int __count;
    int __owner;


    int __kind;
    unsigned int __nusers;
    __extension__ union
    {
      int __spins;
      __pthread_slist_t __list;
    };
  } __data;
  char __size[24];
  long int __align;
} pthread_mutex_t;

typedef union
{
  char __size[4];
  long int __align;
} pthread_mutexattr_t;




typedef union
{
  struct
  {
    int __lock;
    unsigned int __futex;
    __extension__ unsigned long long int __total_seq;
    __extension__ unsigned long long int __wakeup_seq;
    __extension__ unsigned long long int __woken_seq;
    void *__mutex;
    unsigned int __nwaiters;
    unsigned int __broadcast_seq;
  } __data;
  char __size[48];
  __extension__ long long int __align;
} pthread_cond_t;

typedef union
{
  char __size[4];
  long int __align;
} pthread_condattr_t;



typedef unsigned int pthread_key_t;



typedef int pthread_once_t;





typedef union
{
  struct
  {
    int __lock;
    unsigned int __nr_readers;
    unsigned int __readers_wakeup;
    unsigned int __writer_wakeup;
    unsigned int __nr_readers_queued;
    unsigned int __nr_writers_queued;
# 141 "/usr/include/bits/pthreadtypes.h" 3 4
    unsigned char __flags;
    unsigned char __shared;
    unsigned char __pad1;
    unsigned char __pad2;

    int __writer;
  } __data;
  char __size[32];
  long int __align;
} pthread_rwlock_t;

typedef union
{
  char __size[8];
  long int __align;
} pthread_rwlockattr_t;





typedef volatile int pthread_spinlock_t;




typedef union
{
  char __size[20];
  long int __align;
} pthread_barrier_t;

typedef union
{
  char __size[4];
  int __align;
} pthread_barrierattr_t;
# 272 "/usr/include/sys/types.h" 2 3 4



# 321 "/usr/include/stdlib.h" 2 3 4






extern long int random (void) __attribute__ ((__nothrow__));


extern void srandom (unsigned int __seed) __attribute__ ((__nothrow__));





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



extern char *setstate (char *__statebuf) __attribute__ ((__nothrow__)) __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) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));

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

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

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






extern int rand (void) __attribute__ ((__nothrow__));

extern void srand (unsigned int __seed) __attribute__ ((__nothrow__));




extern int rand_r (unsigned int *__seed) __attribute__ ((__nothrow__));







extern double drand48 (void) __attribute__ ((__nothrow__));
extern double erand48 (unsigned short int __xsubi[3]) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


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


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


extern void srand48 (long int __seedval) __attribute__ ((__nothrow__));
extern unsigned short int *seed48 (unsigned short int __seed16v[3])
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
extern void lcong48 (unsigned short int __param[7]) __attribute__ ((__nothrow__)) __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) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
extern int erand48_r (unsigned short int __xsubi[3],
        struct drand48_data *__restrict __buffer,
        double *__restrict __result) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));


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


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


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

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

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









extern void *malloc (size_t __size) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));

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










extern void *realloc (void *__ptr, size_t __size)
     __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));

extern void free (void *__ptr) __attribute__ ((__nothrow__));




extern void cfree (void *__ptr) __attribute__ ((__nothrow__));



# 1 "/usr/include/alloca.h" 1 3 4
# 25 "/usr/include/alloca.h" 3 4
# 1 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include/stddef.h" 1 3 4
# 26 "/usr/include/alloca.h" 2 3 4







extern void *alloca (size_t __size) __attribute__ ((__nothrow__));






# 498 "/usr/include/stdlib.h" 2 3 4





extern void *valloc (size_t __size) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));




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




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



extern int atexit (void (*__func) (void)) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
# 528 "/usr/include/stdlib.h" 3 4
extern int at_quick_exit (void (*__func) (void)) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));







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






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







extern void quick_exit (int __status) __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));







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






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




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





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





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


extern int unsetenv (__const char *__name) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));






extern int clearenv (void) __attribute__ ((__nothrow__));
# 606 "/usr/include/stdlib.h" 3 4
extern char *mktemp (char *__template) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 623 "/usr/include/stdlib.h" 3 4
extern int mkstemp (char *__template) __asm__ ("" "mkstemp64")
     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));





extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 645 "/usr/include/stdlib.h" 3 4
extern int mkstemps (char *__template, int __suffixlen) __asm__ ("" "mkstemps64")
                     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));





extern int mkstemps64 (char *__template, int __suffixlen)
     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 663 "/usr/include/stdlib.h" 3 4
extern char *mkdtemp (char *__template) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 677 "/usr/include/stdlib.h" 3 4
extern int mkostemp (char *__template, int __flags) __asm__ ("" "mkostemp64")
     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));





extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 698 "/usr/include/stdlib.h" 3 4
extern int mkostemps (char *__template, int __suffixlen, int __flags) __asm__ ("" "mkostemps64")

     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));





extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));









extern int system (__const char *__command) __attribute__ ((__warn_unused_result__));






extern char *canonicalize_file_name (__const char *__name)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 734 "/usr/include/stdlib.h" 3 4
extern char *realpath (__const char *__restrict __name,
         char *__restrict __resolved) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));






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


typedef __compar_fn_t comparison_fn_t;



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





extern void *bsearch (__const void *__key, __const void *__base,
        size_t __nmemb, size_t __size, __compar_fn_t __compar)
     __attribute__ ((__nonnull__ (1, 2, 5))) __attribute__ ((__warn_unused_result__));



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

extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
       __compar_d_fn_t __compar, void *__arg)
  __attribute__ ((__nonnull__ (1, 4)));




extern int abs (int __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
extern long int labs (long int __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));



__extension__ extern long long int llabs (long long int __x)
     __attribute__ ((__nothrow__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));







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




__extension__ extern lldiv_t lldiv (long long int __numer,
        long long int __denom)
     __attribute__ ((__nothrow__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));

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




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




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




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




extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign, char *__restrict __buf,
     size_t __len) __attribute__ ((__nothrow__)) __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) __attribute__ ((__nothrow__)) __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)
     __attribute__ ((__nothrow__)) __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)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4, 5)));







extern int mblen (__const char *__s, size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));


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


extern int wctomb (char *__s, wchar_t __wchar) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));



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

extern size_t wcstombs (char *__restrict __s,
   __const wchar_t *__restrict __pwcs, size_t __n)
     __attribute__ ((__nothrow__));








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





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







extern int posix_openpt (int __oflag) __attribute__ ((__warn_unused_result__));







extern int grantpt (int __fd) __attribute__ ((__nothrow__));



extern int unlockpt (int __fd) __attribute__ ((__nothrow__));




extern char *ptsname (int __fd) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));






extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));


extern int getpt (void);






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





# 1 "/usr/include/bits/stdlib.h" 1 3 4
# 24 "/usr/include/bits/stdlib.h" 3 4
extern char *__realpath_chk (__const char *__restrict __name,
        char *__restrict __resolved,
        size_t __resolvedlen) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));
extern char *__realpath_alias (__const char *__restrict __name, char *__restrict __resolved) __asm__ ("" "realpath") __attribute__ ((__nothrow__))

                                                 __attribute__ ((__warn_unused_result__));
extern char *__realpath_chk_warn (__const char *__restrict __name, char *__restrict __resolved, size_t __resolvedlen) __asm__ ("" "__realpath_chk") __attribute__ ((__nothrow__))


                                                __attribute__ ((__warn_unused_result__))
     __attribute__((__warning__ ("second argument of realpath must be either NULL or at " "least PATH_MAX bytes long buffer")))
                                      ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
__attribute__ ((__nothrow__)) realpath (__const char *__restrict __name, char *__restrict __resolved)
{
  if (__builtin_object_size (__resolved, 2 > 1) != (size_t) -1)
    {




      return __realpath_chk (__name, __resolved, __builtin_object_size (__resolved, 2 > 1));
    }

  return __realpath_alias (__name, __resolved);
}


extern int __ptsname_r_chk (int __fd, char *__buf, size_t __buflen,
       size_t __nreal) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
extern int __ptsname_r_alias (int __fd, char *__buf, size_t __buflen) __asm__ ("" "ptsname_r") __attribute__ ((__nothrow__))

     __attribute__ ((__nonnull__ (2)));
extern int __ptsname_r_chk_warn (int __fd, char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__ptsname_r_chk") __attribute__ ((__nothrow__))


     __attribute__ ((__nonnull__ (2))) __attribute__((__warning__ ("ptsname_r called with buflen bigger than " "size of buf")))
                   ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__nothrow__)) ptsname_r (int __fd, char *__buf, size_t __buflen)
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__buflen))
 return __ptsname_r_chk (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
      if (__buflen > __builtin_object_size (__buf, 2 > 1))
 return __ptsname_r_chk_warn (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
    }
  return __ptsname_r_alias (__fd, __buf, __buflen);
}


extern int __wctomb_chk (char *__s, wchar_t __wchar, size_t __buflen)
  __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));
extern int __wctomb_alias (char *__s, wchar_t __wchar) __asm__ ("" "wctomb") __attribute__ ((__nothrow__))
              __attribute__ ((__warn_unused_result__));

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) int
__attribute__ ((__nothrow__)) wctomb (char *__s, wchar_t __wchar)
{







  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 && 16 > __builtin_object_size (__s, 2 > 1))
    return __wctomb_chk (__s, __wchar, __builtin_object_size (__s, 2 > 1));
  return __wctomb_alias (__s, __wchar);
}


extern size_t __mbstowcs_chk (wchar_t *__restrict __dst,
         __const char *__restrict __src,
         size_t __len, size_t __dstlen) __attribute__ ((__nothrow__));
extern size_t __mbstowcs_alias (wchar_t *__restrict __dst, __const char *__restrict __src, size_t __len) __asm__ ("" "mbstowcs") __attribute__ ((__nothrow__))


                                  ;
extern size_t __mbstowcs_chk_warn (wchar_t *__restrict __dst, __const char *__restrict __src, size_t __len, size_t __dstlen) __asm__ ("" "__mbstowcs_chk") __attribute__ ((__nothrow__))



     __attribute__((__warning__ ("mbstowcs called with dst buffer smaller than len " "* sizeof (wchar_t)")))
                        ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) size_t
__attribute__ ((__nothrow__)) mbstowcs (wchar_t *__restrict __dst, __const char *__restrict __src, size_t __len)

{
  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
 return __mbstowcs_chk (__dst, __src, __len,
          __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));

      if (__len > __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t))
 return __mbstowcs_chk_warn (__dst, __src, __len,
         __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
    }
  return __mbstowcs_alias (__dst, __src, __len);
}


extern size_t __wcstombs_chk (char *__restrict __dst,
         __const wchar_t *__restrict __src,
         size_t __len, size_t __dstlen) __attribute__ ((__nothrow__));
extern size_t __wcstombs_alias (char *__restrict __dst, __const wchar_t *__restrict __src, size_t __len) __asm__ ("" "wcstombs") __attribute__ ((__nothrow__))


                                  ;
extern size_t __wcstombs_chk_warn (char *__restrict __dst, __const wchar_t *__restrict __src, size_t __len, size_t __dstlen) __asm__ ("" "__wcstombs_chk") __attribute__ ((__nothrow__))



     __attribute__((__warning__ ("wcstombs called with dst buffer smaller than len")));

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) size_t
__attribute__ ((__nothrow__)) wcstombs (char *__restrict __dst, __const wchar_t *__restrict __src, size_t __len)

{
  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
 return __wcstombs_chk (__dst, __src, __len, __builtin_object_size (__dst, 2 > 1));
      if (__len > __builtin_object_size (__dst, 2 > 1))
 return __wcstombs_chk_warn (__dst, __src, __len, __builtin_object_size (__dst, 2 > 1));
    }
  return __wcstombs_alias (__dst, __src, __len);
}
# 956 "/usr/include/stdlib.h" 2 3 4
# 964 "/usr/include/stdlib.h" 3 4

# 21 "../../target-i386/translate.c" 2
# 1 "/usr/include/stdio.h" 1 3 4
# 30 "/usr/include/stdio.h" 3 4




# 1 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include/stddef.h" 1 3 4
# 35 "/usr/include/stdio.h" 2 3 4
# 45 "/usr/include/stdio.h" 3 4
struct _IO_FILE;



typedef struct _IO_FILE FILE;





# 65 "/usr/include/stdio.h" 3 4
typedef struct _IO_FILE __FILE;
# 75 "/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
# 15 "/usr/include/_G_config.h" 3 4
# 1 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include/stddef.h" 1 3 4
# 16 "/usr/include/_G_config.h" 2 3 4




# 1 "/usr/include/wchar.h" 1 3 4
# 83 "/usr/include/wchar.h" 3 4
typedef struct
{
  int __count;
  union
  {

    unsigned int __wch;



    char __wchb[4];
  } __value;
} __mbstate_t;
# 21 "/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;
# 53 "/usr/include/_G_config.h" 3 4
typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));
# 33 "/usr/include/libio.h" 2 3 4
# 170 "/usr/include/libio.h" 3 4
struct _IO_jump_t; struct _IO_FILE;
# 180 "/usr/include/libio.h" 3 4
typedef void _IO_lock_t;





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



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


enum __codecvt_result
{
  __codecvt_ok,
  __codecvt_partial,
  __codecvt_error,
  __codecvt_noconv
};
# 271 "/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;
# 319 "/usr/include/libio.h" 3 4
  __off64_t _offset;
# 328 "/usr/include/libio.h" 3 4
  void *__pad1;
  void *__pad2;
  void *__pad3;
  void *__pad4;
  size_t __pad5;

  int _mode;

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

};


typedef struct _IO_FILE _IO_FILE;


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_;
# 364 "/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 int __underflow (_IO_FILE *);
extern int __uflow (_IO_FILE *);
extern int __overflow (_IO_FILE *, int);
# 460 "/usr/include/libio.h" 3 4
extern int _IO_getc (_IO_FILE *__fp);
extern int _IO_putc (int __c, _IO_FILE *__fp);
extern int _IO_feof (_IO_FILE *__fp) __attribute__ ((__nothrow__));
extern int _IO_ferror (_IO_FILE *__fp) __attribute__ ((__nothrow__));

extern int _IO_peekc_locked (_IO_FILE *__fp);





extern void _IO_flockfile (_IO_FILE *) __attribute__ ((__nothrow__));
extern void _IO_funlockfile (_IO_FILE *) __attribute__ ((__nothrow__));
extern int _IO_ftrylockfile (_IO_FILE *) __attribute__ ((__nothrow__));
# 490 "/usr/include/libio.h" 3 4
extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
   __gnuc_va_list, int *__restrict);
extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
    __gnuc_va_list);
extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);

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

extern void _IO_free_backup_area (_IO_FILE *) __attribute__ ((__nothrow__));
# 76 "/usr/include/stdio.h" 2 3 4
# 109 "/usr/include/stdio.h" 3 4




typedef _G_fpos64_t fpos_t;



typedef _G_fpos64_t fpos64_t;
# 161 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
# 162 "/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) __attribute__ ((__nothrow__));

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




extern int renameat (int __oldfd, __const char *__old, int __newfd,
       __const char *__new) __attribute__ ((__nothrow__));



# 195 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile (void) __asm__ ("" "tmpfile64") __attribute__ ((__warn_unused_result__));






extern FILE *tmpfile64 (void) __attribute__ ((__warn_unused_result__));



extern char *tmpnam (char *__s) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));





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








extern int fclose (FILE *__stream);




extern int fflush (FILE *__stream);

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




# 280 "/usr/include/stdio.h" 3 4
extern FILE *fopen (__const char *__restrict __filename, __const char *__restrict __modes) __asm__ ("" "fopen64")

  __attribute__ ((__warn_unused_result__));
extern FILE *freopen (__const char *__restrict __filename, __const char *__restrict __modes, FILE *__restrict __stream) __asm__ ("" "freopen64")


  __attribute__ ((__warn_unused_result__));







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




extern FILE *fdopen (int __fd, __const char *__modes) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));





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




extern FILE *fmemopen (void *__s, size_t __len, __const char *__modes)
  __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));




extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));






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



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





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


extern void setlinebuf (FILE *__stream) __attribute__ ((__nothrow__));








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, ...) __attribute__ ((__nothrow__));





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





extern int snprintf (char *__restrict __s, size_t __maxlen,
       __const char *__restrict __format, ...)
     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 4)));

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






extern int vasprintf (char **__restrict __ptr, __const char *__restrict __f,
        __gnuc_va_list __arg)
     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 0))) __attribute__ ((__warn_unused_result__));
extern int __asprintf (char **__restrict __ptr,
         __const char *__restrict __fmt, ...)
     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 3))) __attribute__ ((__warn_unused_result__));
extern int asprintf (char **__restrict __ptr,
       __const char *__restrict __fmt, ...)
     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 3))) __attribute__ ((__warn_unused_result__));
# 414 "/usr/include/stdio.h" 3 4
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, ...) __attribute__ ((__warn_unused_result__));




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

extern int sscanf (__const char *__restrict __s,
     __const char *__restrict __format, ...) __attribute__ ((__nothrow__));
# 465 "/usr/include/stdio.h" 3 4








extern int vfscanf (FILE *__restrict __s, __const char *__restrict __format,
      __gnuc_va_list __arg)
     __attribute__ ((__format__ (__scanf__, 2, 0))) __attribute__ ((__warn_unused_result__));





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


extern int vsscanf (__const char *__restrict __s,
      __const char *__restrict __format, __gnuc_va_list __arg)
     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__scanf__, 2, 0)));
# 524 "/usr/include/stdio.h" 3 4









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





extern int getchar (void);

# 552 "/usr/include/stdio.h" 3 4
extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
# 563 "/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);

# 596 "/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)
     __attribute__ ((__warn_unused_result__));






extern char *gets (char *__s) __attribute__ ((__warn_unused_result__));

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







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








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




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

# 719 "/usr/include/stdio.h" 3 4
extern int fputs_unlocked (__const char *__restrict __s,
      FILE *__restrict __stream);
# 730 "/usr/include/stdio.h" 3 4
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
         size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
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) __attribute__ ((__warn_unused_result__));




extern void rewind (FILE *__stream);

# 774 "/usr/include/stdio.h" 3 4
extern int fseeko (FILE *__stream, __off64_t __off, int __whence) __asm__ ("" "fseeko64")

                  ;
extern __off64_t ftello (FILE *__stream) __asm__ ("" "ftello64");








# 799 "/usr/include/stdio.h" 3 4
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos) __asm__ ("" "fgetpos64")
                                          ;
extern int fsetpos (FILE *__stream, __const fpos_t *__pos) __asm__ ("" "fsetpos64")
                                                            ;








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




extern void clearerr (FILE *__stream) __attribute__ ((__nothrow__));

extern int feof (FILE *__stream) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));

extern int ferror (FILE *__stream) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));




extern void clearerr_unlocked (FILE *__stream) __attribute__ ((__nothrow__));
extern int feof_unlocked (FILE *__stream) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));
extern int ferror_unlocked (FILE *__stream) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));








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[];
# 847 "/usr/include/stdio.h" 2 3 4




extern int fileno (FILE *__stream) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));




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





extern int pclose (FILE *__stream);





extern char *ctermid (char *__s) __attribute__ ((__nothrow__));





extern char *cuserid (char *__s);




struct obstack;


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







extern void flockfile (FILE *__stream) __attribute__ ((__nothrow__));



extern int ftrylockfile (FILE *__stream) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));


extern void funlockfile (FILE *__stream) __attribute__ ((__nothrow__));
# 927 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio.h" 1 3 4
# 44 "/usr/include/bits/stdio.h" 3 4
extern __inline int
getchar (void)
{
  return _IO_getc (stdin);
}




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





extern __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++);
}


extern __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++);
}




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




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





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


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





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





extern __inline int
__attribute__ ((__nothrow__)) feof_unlocked (FILE *__stream)
{
  return (((__stream)->_flags & 0x10) != 0);
}


extern __inline int
__attribute__ ((__nothrow__)) ferror_unlocked (FILE *__stream)
{
  return (((__stream)->_flags & 0x20) != 0);
}
# 928 "/usr/include/stdio.h" 2 3 4


# 1 "/usr/include/bits/stdio2.h" 1 3 4
# 24 "/usr/include/bits/stdio2.h" 3 4
extern int __sprintf_chk (char *__restrict __s, int __flag, size_t __slen,
     __const char *__restrict __format, ...) __attribute__ ((__nothrow__));
extern int __vsprintf_chk (char *__restrict __s, int __flag, size_t __slen,
      __const char *__restrict __format,
      __gnuc_va_list __ap) __attribute__ ((__nothrow__));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__nothrow__)) sprintf (char *__restrict __s, __const char *__restrict __fmt, ...)
{
  return __builtin___sprintf_chk (__s, 2 - 1,
      __builtin_object_size (__s, 2 > 1), __fmt, __builtin_va_arg_pack ());
}






extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__nothrow__)) vsprintf (char *__restrict __s, __const char *__restrict __fmt, __gnuc_va_list __ap)

{
  return __builtin___vsprintf_chk (__s, 2 - 1,
       __builtin_object_size (__s, 2 > 1), __fmt, __ap);
}



extern int __snprintf_chk (char *__restrict __s, size_t __n, int __flag,
      size_t __slen, __const char *__restrict __format,
      ...) __attribute__ ((__nothrow__));
extern int __vsnprintf_chk (char *__restrict __s, size_t __n, int __flag,
       size_t __slen, __const char *__restrict __format,
       __gnuc_va_list __ap) __attribute__ ((__nothrow__));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__nothrow__)) snprintf (char *__restrict __s, size_t __n, __const char *__restrict __fmt, ...)

{
  return __builtin___snprintf_chk (__s, __n, 2 - 1,
       __builtin_object_size (__s, 2 > 1), __fmt, __builtin_va_arg_pack ());
}






extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__nothrow__)) vsnprintf (char *__restrict __s, size_t __n, __const char *__restrict __fmt, __gnuc_va_list __ap)

{
  return __builtin___vsnprintf_chk (__s, __n, 2 - 1,
        __builtin_object_size (__s, 2 > 1), __fmt, __ap);
}





extern int __fprintf_chk (FILE *__restrict __stream, int __flag,
     __const char *__restrict __format, ...);
extern int __printf_chk (int __flag, __const char *__restrict __format, ...);
extern int __vfprintf_chk (FILE *__restrict __stream, int __flag,
      __const char *__restrict __format, __gnuc_va_list __ap);
extern int __vprintf_chk (int __flag, __const char *__restrict __format,
     __gnuc_va_list __ap);


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
fprintf (FILE *__restrict __stream, __const char *__restrict __fmt, ...)
{
  return __fprintf_chk (__stream, 2 - 1, __fmt,
   __builtin_va_arg_pack ());
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
printf (__const char *__restrict __fmt, ...)
{
  return __printf_chk (2 - 1, __fmt, __builtin_va_arg_pack ());
}







extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
vprintf (__const char *__restrict __fmt, __gnuc_va_list __ap)
{

  return __vfprintf_chk (stdout, 2 - 1, __fmt, __ap);



}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
vfprintf (FILE *__restrict __stream,
   __const char *__restrict __fmt, __gnuc_va_list __ap)
{
  return __vfprintf_chk (__stream, 2 - 1, __fmt, __ap);
}



extern int __asprintf_chk (char **__restrict __ptr, int __flag,
      __const char *__restrict __fmt, ...)
     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 4))) __attribute__ ((__warn_unused_result__));
extern int __vasprintf_chk (char **__restrict __ptr, int __flag,
       __const char *__restrict __fmt, __gnuc_va_list __arg)
     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 0))) __attribute__ ((__warn_unused_result__));
extern int __dprintf_chk (int __fd, int __flag, __const char *__restrict __fmt,
     ...) __attribute__ ((__format__ (__printf__, 3, 4)));
extern int __vdprintf_chk (int __fd, int __flag,
      __const char *__restrict __fmt, __gnuc_va_list __arg)
     __attribute__ ((__format__ (__printf__, 3, 0)));
extern int __obstack_printf_chk (struct obstack *__restrict __obstack,
     int __flag, __const char *__restrict __format,
     ...)
     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 4)));
extern int __obstack_vprintf_chk (struct obstack *__restrict __obstack,
      int __flag,
      __const char *__restrict __format,
      __gnuc_va_list __args)
     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 0)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__nothrow__)) asprintf (char **__restrict __ptr, __const char *__restrict __fmt, ...)
{
  return __asprintf_chk (__ptr, 2 - 1, __fmt,
    __builtin_va_arg_pack ());
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__nothrow__)) __asprintf (char **__restrict __ptr, __const char *__restrict __fmt, ...)

{
  return __asprintf_chk (__ptr, 2 - 1, __fmt,
    __builtin_va_arg_pack ());
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
dprintf (int __fd, __const char *__restrict __fmt, ...)
{
  return __dprintf_chk (__fd, 2 - 1, __fmt,
   __builtin_va_arg_pack ());
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__nothrow__)) obstack_printf (struct obstack *__restrict __obstack, __const char *__restrict __fmt, ...)

{
  return __obstack_printf_chk (__obstack, 2 - 1, __fmt,
          __builtin_va_arg_pack ());
}
# 195 "/usr/include/bits/stdio2.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__nothrow__)) vasprintf (char **__restrict __ptr, __const char *__restrict __fmt, __gnuc_va_list __ap)

{
  return __vasprintf_chk (__ptr, 2 - 1, __fmt, __ap);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
vdprintf (int __fd, __const char *__restrict __fmt, __gnuc_va_list __ap)
{
  return __vdprintf_chk (__fd, 2 - 1, __fmt, __ap);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__nothrow__)) obstack_vprintf (struct obstack *__restrict __obstack, __const char *__restrict __fmt, __gnuc_va_list __ap)

{
  return __obstack_vprintf_chk (__obstack, 2 - 1, __fmt,
    __ap);
}





extern char *__gets_chk (char *__str, size_t) __attribute__ ((__warn_unused_result__));
extern char *__gets_warn (char *__str) __asm__ ("" "gets")
     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("please use fgets or getline instead, gets can't " "specify buffer size")))
                               ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
gets (char *__str)
{
  if (__builtin_object_size (__str, 2 > 1) != (size_t) -1)
    return __gets_chk (__str, __builtin_object_size (__str, 2 > 1));
  return __gets_warn (__str);
}

extern char *__fgets_chk (char *__restrict __s, size_t __size, int __n,
     FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
extern char *__fgets_alias (char *__restrict __s, int __n, FILE *__restrict __stream) __asm__ ("" "fgets")

                                        __attribute__ ((__warn_unused_result__));
extern char *__fgets_chk_warn (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __asm__ ("" "__fgets_chk")


     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgets called with bigger size than length " "of destination buffer")))
                                 ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
{
  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n) || __n <= 0)
 return __fgets_chk (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);

      if ((size_t) __n > __builtin_object_size (__s, 2 > 1))
 return __fgets_chk_warn (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
    }
  return __fgets_alias (__s, __n, __stream);
}

extern size_t __fread_chk (void *__restrict __ptr, size_t __ptrlen,
      size_t __size, size_t __n,
      FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
extern size_t __fread_alias (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "fread")


            __attribute__ ((__warn_unused_result__));
extern size_t __fread_chk_warn (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "__fread_chk")




     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fread called with bigger size * nmemb than length " "of destination buffer")))
                                 ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) size_t
fread (void *__restrict __ptr, size_t __size, size_t __n,
       FILE *__restrict __stream)
{
  if (__builtin_object_size (__ptr, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__size)
   || !__builtin_constant_p (__n)
   || (__size | __n) >= (((size_t) 1) << (8 * sizeof (size_t) / 2)))
 return __fread_chk (__ptr, __builtin_object_size (__ptr, 0), __size, __n, __stream);

      if (__size * __n > __builtin_object_size (__ptr, 0))
 return __fread_chk_warn (__ptr, __builtin_object_size (__ptr, 0), __size, __n, __stream);
    }
  return __fread_alias (__ptr, __size, __n, __stream);
}


extern char *__fgets_unlocked_chk (char *__restrict __s, size_t __size,
       int __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
extern char *__fgets_unlocked_alias (char *__restrict __s, int __n, FILE *__restrict __stream) __asm__ ("" "fgets_unlocked")

                                                 __attribute__ ((__warn_unused_result__));
extern char *__fgets_unlocked_chk_warn (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __asm__ ("" "__fgets_unlocked_chk")


     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgets_unlocked called with bigger size than length " "of destination buffer")))
                                 ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
fgets_unlocked (char *__restrict __s, int __n, FILE *__restrict __stream)
{
  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n) || __n <= 0)
 return __fgets_unlocked_chk (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);

      if ((size_t) __n > __builtin_object_size (__s, 2 > 1))
 return __fgets_unlocked_chk_warn (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
    }
  return __fgets_unlocked_alias (__s, __n, __stream);
}




extern size_t __fread_unlocked_chk (void *__restrict __ptr, size_t __ptrlen,
        size_t __size, size_t __n,
        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
extern size_t __fread_unlocked_alias (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "fread_unlocked")


                     __attribute__ ((__warn_unused_result__));
extern size_t __fread_unlocked_chk_warn (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "__fread_unlocked_chk")




     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fread_unlocked called with bigger size * nmemb than " "length of destination buffer")))
                                        ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) size_t
fread_unlocked (void *__restrict __ptr, size_t __size, size_t __n,
  FILE *__restrict __stream)
{
  if (__builtin_object_size (__ptr, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__size)
   || !__builtin_constant_p (__n)
   || (__size | __n) >= (((size_t) 1) << (8 * sizeof (size_t) / 2)))
 return __fread_unlocked_chk (__ptr, __builtin_object_size (__ptr, 0), __size, __n,
         __stream);

      if (__size * __n > __builtin_object_size (__ptr, 0))
 return __fread_unlocked_chk_warn (__ptr, __builtin_object_size (__ptr, 0), __size, __n,
       __stream);
    }


  if (__builtin_constant_p (__size)
      && __builtin_constant_p (__n)
      && (__size | __n) < (((size_t) 1) << (8 * sizeof (size_t) / 2))
      && __size * __n <= 8)
    {
      size_t __cnt = __size * __n;
      char *__cptr = (char *) __ptr;
      if (__cnt == 0)
 return 0;

      for (; __cnt > 0; --__cnt)
 {
   int __c = (__builtin_expect (((__stream)->_IO_read_ptr >= (__stream)->_IO_read_end), 0) ? __uflow (__stream) : *(unsigned char *) (__stream)->_IO_read_ptr++);
   if (__c == (-1))
     break;
   *__cptr++ = __c;
 }
      return (__cptr - (char *) __ptr) / __size;
    }

  return __fread_unlocked_alias (__ptr, __size, __n, __stream);
}
# 931 "/usr/include/stdio.h" 2 3 4






# 22 "../../target-i386/translate.c" 2
# 1 "/usr/include/string.h" 1 3 4
# 29 "/usr/include/string.h" 3 4





# 1 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include/stddef.h" 1 3 4
# 35 "/usr/include/string.h" 2 3 4









extern void *memcpy (void *__restrict __dest,
       __const void *__restrict __src, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));


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






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





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


extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 95 "/usr/include/string.h" 3 4
extern void *memchr (__const void *__s, int __c, size_t __n)
      __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


# 109 "/usr/include/string.h" 3 4
extern void *rawmemchr (__const void *__s, int __c)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 120 "/usr/include/string.h" 3 4
extern void *memrchr (__const void *__s, int __c, size_t __n)
      __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));






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

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


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

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


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

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


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

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

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

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





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






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

# 235 "/usr/include/string.h" 3 4
extern char *strchr (__const char *__s, int __c)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 262 "/usr/include/string.h" 3 4
extern char *strrchr (__const char *__s, int __c)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


# 276 "/usr/include/string.h" 3 4
extern char *strchrnul (__const char *__s, int __c)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));






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


extern size_t strspn (__const char *__s, __const char *__accept)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 314 "/usr/include/string.h" 3 4
extern char *strpbrk (__const char *__s, __const char *__accept)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 342 "/usr/include/string.h" 3 4
extern char *strstr (__const char *__haystack, __const char *__needle)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));




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




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

extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim,
         char **__restrict __save_ptr)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));
# 373 "/usr/include/string.h" 3 4
extern char *strcasestr (__const char *__haystack, __const char *__needle)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));







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



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





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





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





extern char *strerror (int __errnum) __attribute__ ((__nothrow__));

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





extern char *strerror_l (int __errnum, __locale_t __l) __attribute__ ((__nothrow__));





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



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


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


extern int bcmp (__const void *__s1, __const void *__s2, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 489 "/usr/include/string.h" 3 4
extern char *index (__const char *__s, int __c)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 517 "/usr/include/string.h" 3 4
extern char *rindex (__const char *__s, int __c)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));




extern int ffs (int __i) __attribute__ ((__nothrow__)) __attribute__ ((__const__));




extern int ffsl (long int __l) __attribute__ ((__nothrow__)) __attribute__ ((__const__));

__extension__ extern int ffsll (long long int __ll)
     __attribute__ ((__nothrow__)) __attribute__ ((__const__));




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


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





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

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





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




extern char *strsignal (int __sig) __attribute__ ((__nothrow__));


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



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




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


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


extern void *memfrob (void *__s, size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
# 606 "/usr/include/string.h" 3 4
extern char *basename (__const char *__filename) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
# 634 "/usr/include/string.h" 3 4
# 1 "/usr/include/bits/string.h" 1 3 4
# 635 "/usr/include/string.h" 2 3 4


# 1 "/usr/include/bits/string2.h" 1 3 4
# 80 "/usr/include/bits/string2.h" 3 4
typedef struct { unsigned char __arr[2]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR2;
typedef struct { unsigned char __arr[3]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR3;
typedef struct { unsigned char __arr[4]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR4;
typedef struct { unsigned char __arr[5]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR5;
typedef struct { unsigned char __arr[6]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR6;
typedef struct { unsigned char __arr[7]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR7;
typedef struct { unsigned char __arr[8]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR8;
# 394 "/usr/include/bits/string2.h" 3 4
extern void *__rawmemchr (const void *__s, int __c);
# 969 "/usr/include/bits/string2.h" 3 4
extern __inline size_t __strcspn_c1 (__const char *__s, int __reject);
extern __inline size_t
__strcspn_c1 (__const char *__s, int __reject)
{
  register size_t __result = 0;
  while (__s[__result] != '\0' && __s[__result] != __reject)
    ++__result;
  return __result;
}

extern __inline size_t __strcspn_c2 (__const char *__s, int __reject1,
         int __reject2);
extern __inline size_t
__strcspn_c2 (__const char *__s, int __reject1, int __reject2)
{
  register size_t __result = 0;
  while (__s[__result] != '\0' && __s[__result] != __reject1
  && __s[__result] != __reject2)
    ++__result;
  return __result;
}

extern __inline size_t __strcspn_c3 (__const char *__s, int __reject1,
         int __reject2, int __reject3);
extern __inline size_t
__strcspn_c3 (__const char *__s, int __reject1, int __reject2,
       int __reject3)
{
  register size_t __result = 0;
  while (__s[__result] != '\0' && __s[__result] != __reject1
  && __s[__result] != __reject2 && __s[__result] != __reject3)
    ++__result;
  return __result;
}
# 1045 "/usr/include/bits/string2.h" 3 4
extern __inline size_t __strspn_c1 (__const char *__s, int __accept);
extern __inline size_t
__strspn_c1 (__const char *__s, int __accept)
{
  register size_t __result = 0;

  while (__s[__result] == __accept)
    ++__result;
  return __result;
}

extern __inline size_t __strspn_c2 (__const char *__s, int __accept1,
        int __accept2);
extern __inline size_t
__strspn_c2 (__const char *__s, int __accept1, int __accept2)
{
  register size_t __result = 0;

  while (__s[__result] == __accept1 || __s[__result] == __accept2)
    ++__result;
  return __result;
}

extern __inline size_t __strspn_c3 (__const char *__s, int __accept1,
        int __accept2, int __accept3);
extern __inline size_t
__strspn_c3 (__const char *__s, int __accept1, int __accept2, int __accept3)
{
  register size_t __result = 0;

  while (__s[__result] == __accept1 || __s[__result] == __accept2
  || __s[__result] == __accept3)
    ++__result;
  return __result;
}
# 1121 "/usr/include/bits/string2.h" 3 4
extern __inline char *__strpbrk_c2 (__const char *__s, int __accept1,
         int __accept2);
extern __inline char *
__strpbrk_c2 (__const char *__s, int __accept1, int __accept2)
{

  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2)
    ++__s;
  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
}

extern __inline char *__strpbrk_c3 (__const char *__s, int __accept1,
         int __accept2, int __accept3);
extern __inline char *
__strpbrk_c3 (__const char *__s, int __accept1, int __accept2,
       int __accept3)
{

  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2
  && *__s != __accept3)
    ++__s;
  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
}
# 1172 "/usr/include/bits/string2.h" 3 4
extern __inline char *__strtok_r_1c (char *__s, char __sep, char **__nextp);
extern __inline char *
__strtok_r_1c (char *__s, char __sep, char **__nextp)
{
  char *__result;
  if (__s == ((void *)0))
    __s = *__nextp;
  while (*__s == __sep)
    ++__s;
  __result = ((void *)0);
  if (*__s != '\0')
    {
      __result = __s++;
      while (*__s != '\0')
 if (*__s++ == __sep)
   {
     __s[-1] = '\0';
     break;
   }
    }
  *__nextp = __s;
  return __result;
}
# 1204 "/usr/include/bits/string2.h" 3 4
extern char *__strsep_g (char **__stringp, __const char *__delim);
# 1222 "/usr/include/bits/string2.h" 3 4
extern __inline char *__strsep_1c (char **__s, char __reject);
extern __inline char *
__strsep_1c (char **__s, char __reject)
{
  register char *__retval = *__s;
  if (__retval != ((void *)0) && (*__s = (__extension__ (__builtin_constant_p (__reject) && !__builtin_constant_p (__retval) && (__reject) == '\0' ? (char *) __rawmemchr (__retval, __reject) : __builtin_strchr (__retval, __reject)))) != ((void *)0))
    *(*__s)++ = '\0';
  return __retval;
}

extern __inline char *__strsep_2c (char **__s, char __reject1, char __reject2);
extern __inline char *
__strsep_2c (char **__s, char __reject1, char __reject2)
{
  register char *__retval = *__s;
  if (__retval != ((void *)0))
    {
      register char *__cp = __retval;
      while (1)
 {
   if (*__cp == '\0')
     {
       __cp = ((void *)0);
   break;
     }
   if (*__cp == __reject1 || *__cp == __reject2)
     {
       *__cp++ = '\0';
       break;
     }
   ++__cp;
 }
      *__s = __cp;
    }
  return __retval;
}

extern __inline char *__strsep_3c (char **__s, char __reject1, char __reject2,
       char __reject3);
extern __inline char *
__strsep_3c (char **__s, char __reject1, char __reject2, char __reject3)
{
  register char *__retval = *__s;
  if (__retval != ((void *)0))
    {
      register char *__cp = __retval;
      while (1)
 {
   if (*__cp == '\0')
     {
       __cp = ((void *)0);
   break;
     }
   if (*__cp == __reject1 || *__cp == __reject2 || *__cp == __reject3)
     {
       *__cp++ = '\0';
       break;
     }
   ++__cp;
 }
      *__s = __cp;
    }
  return __retval;
}
# 1303 "/usr/include/bits/string2.h" 3 4
extern char *__strdup (__const char *__string) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));
# 1322 "/usr/include/bits/string2.h" 3 4
extern char *__strndup (__const char *__string, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));
# 638 "/usr/include/string.h" 2 3 4




# 1 "/usr/include/bits/string3.h" 1 3 4
# 23 "/usr/include/bits/string3.h" 3 4
extern void __warn_memset_zero_len (void) __attribute__((__warning__ ("memset used with constant zero length parameter; this could be due to transposed parameters")))
                                                                                                   ;
# 48 "/usr/include/bits/string3.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void *
__attribute__ ((__nothrow__)) memcpy (void *__restrict __dest, __const void *__restrict __src, size_t __len)

{
  return __builtin___memcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void *
__attribute__ ((__nothrow__)) memmove (void *__dest, __const void *__src, size_t __len)
{
  return __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
}


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void *
__attribute__ ((__nothrow__)) mempcpy (void *__restrict __dest, __const void *__restrict __src, size_t __len)

{
  return __builtin___mempcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
}
# 76 "/usr/include/bits/string3.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void *
__attribute__ ((__nothrow__)) memset (void *__dest, int __ch, size_t __len)
{
  if (__builtin_constant_p (__len) && __len == 0
      && (!__builtin_constant_p (__ch) || __ch != 0))
    {
      __warn_memset_zero_len ();
      return __dest;
    }
  return __builtin___memset_chk (__dest, __ch, __len, __builtin_object_size (__dest, 0));
}


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void
__attribute__ ((__nothrow__)) bcopy (__const void *__src, void *__dest, size_t __len)
{
  (void) __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void
__attribute__ ((__nothrow__)) bzero (void *__dest, size_t __len)
{
  (void) __builtin___memset_chk (__dest, '\0', __len, __builtin_object_size (__dest, 0));
}


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
__attribute__ ((__nothrow__)) strcpy (char *__restrict __dest, __const char *__restrict __src)
{
  return __builtin___strcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
}


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
__attribute__ ((__nothrow__)) stpcpy (char *__restrict __dest, __const char *__restrict __src)
{
  return __builtin___stpcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
}



extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
__attribute__ ((__nothrow__)) strncpy (char *__restrict __dest, __const char *__restrict __src, size_t __len)

{
  return __builtin___strncpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
}


extern char *__stpncpy_chk (char *__dest, __const char *__src, size_t __n,
       size_t __destlen) __attribute__ ((__nothrow__));
extern char *__stpncpy_alias (char *__dest, __const char *__src, size_t __n) __asm__ ("" "stpncpy") __attribute__ ((__nothrow__))

                                 ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
__attribute__ ((__nothrow__)) stpncpy (char *__dest, __const char *__src, size_t __n)
{
  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1
      && (!__builtin_constant_p (__n) || __n <= __builtin_object_size (__dest, 2 > 1)))
    return __stpncpy_chk (__dest, __src, __n, __builtin_object_size (__dest, 2 > 1));
  return __stpncpy_alias (__dest, __src, __n);
}


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
__attribute__ ((__nothrow__)) strcat (char *__restrict __dest, __const char *__restrict __src)
{
  return __builtin___strcat_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
}


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
__attribute__ ((__nothrow__)) strncat (char *__restrict __dest, __const char *__restrict __src, size_t __len)

{
  return __builtin___strncat_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
}
# 643 "/usr/include/string.h" 2 3 4




# 23 "../../target-i386/translate.c" 2
# 1 "/usr/include/inttypes.h" 1 3 4
# 28 "/usr/include/inttypes.h" 3 4
# 1 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include/stdint.h" 1 3 4


# 1 "/usr/include/stdint.h" 1 3 4
# 27 "/usr/include/stdint.h" 3 4
# 1 "/usr/include/bits/wchar.h" 1 3 4
# 28 "/usr/include/stdint.h" 2 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;
# 126 "/usr/include/stdint.h" 3 4
typedef int intptr_t;


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;
# 4 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include/stdint.h" 2 3 4
# 29 "/usr/include/inttypes.h" 2 3 4






typedef unsigned int __gwchar_t;
# 274 "/usr/include/inttypes.h" 3 4

# 288 "/usr/include/inttypes.h" 3 4
typedef struct
  {
    long long int quot;
    long long int rem;
  } imaxdiv_t;





extern intmax_t imaxabs (intmax_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom)
      __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern intmax_t strtoimax (__const char *__restrict __nptr,
      char **__restrict __endptr, int __base) __attribute__ ((__nothrow__));


extern uintmax_t strtoumax (__const char *__restrict __nptr,
       char ** __restrict __endptr, int __base) __attribute__ ((__nothrow__));


extern intmax_t wcstoimax (__const __gwchar_t *__restrict __nptr,
      __gwchar_t **__restrict __endptr, int __base)
     __attribute__ ((__nothrow__));


extern uintmax_t wcstoumax (__const __gwchar_t *__restrict __nptr,
       __gwchar_t ** __restrict __endptr, int __base)
     __attribute__ ((__nothrow__));
# 379 "/usr/include/inttypes.h" 3 4
__extension__
extern long long int __strtoll_internal (__const char *__restrict __nptr,
      char **__restrict __endptr,
      int __base, int __group)
  __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));

extern __inline intmax_t
__attribute__ ((__nothrow__)) strtoimax (__const char *__restrict nptr, char **__restrict endptr, int base)

{
  return __strtoll_internal (nptr, endptr, base, 0);
}

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

extern __inline uintmax_t
__attribute__ ((__nothrow__)) strtoumax (__const char *__restrict nptr, char **__restrict endptr, int base)

{
  return __strtoull_internal (nptr, endptr, base, 0);
}

__extension__
extern long long int __wcstoll_internal (__const __gwchar_t *
      __restrict __nptr,
      __gwchar_t **__restrict __endptr,
      int __base, int __group)
  __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));

extern __inline intmax_t
__attribute__ ((__nothrow__)) wcstoimax (__const __gwchar_t *__restrict nptr, __gwchar_t **__restrict endptr, int base)

{
  return __wcstoll_internal (nptr, endptr, base, 0);
}


__extension__
extern unsigned long long int __wcstoull_internal (__const __gwchar_t *
         __restrict __nptr,
         __gwchar_t **
         __restrict __endptr,
         int __base,
         int __group)
  __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));

extern __inline uintmax_t
__attribute__ ((__nothrow__)) wcstoumax (__const __gwchar_t *__restrict nptr, __gwchar_t **__restrict endptr, int base)

{
  return __wcstoull_internal (nptr, endptr, base, 0);
}





# 24 "../../target-i386/translate.c" 2
# 1 "/usr/include/signal.h" 1 3 4
# 31 "/usr/include/signal.h" 3 4


# 1 "/usr/include/bits/sigset.h" 1 3 4
# 104 "/usr/include/bits/sigset.h" 3 4
extern int __sigismember (__const __sigset_t *, int);
extern int __sigaddset (__sigset_t *, int);
extern int __sigdelset (__sigset_t *, int);
# 118 "/usr/include/bits/sigset.h" 3 4
extern __inline int __sigismember (__const __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return (__set->__val[__word] & __mask) ? 1 : 0; }
extern __inline int __sigaddset ( __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return ((__set->__val[__word] |= __mask), 0); }
extern __inline int __sigdelset ( __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return ((__set->__val[__word] &= ~__mask), 0); }
# 34 "/usr/include/signal.h" 2 3 4







typedef __sig_atomic_t sig_atomic_t;

# 58 "/usr/include/signal.h" 3 4
# 1 "/usr/include/bits/signum.h" 1 3 4
# 59 "/usr/include/signal.h" 2 3 4
# 76 "/usr/include/signal.h" 3 4
# 1 "/usr/include/time.h" 1 3 4
# 77 "/usr/include/signal.h" 2 3 4


# 1 "/usr/include/bits/siginfo.h" 1 3 4
# 25 "/usr/include/bits/siginfo.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 26 "/usr/include/bits/siginfo.h" 2 3 4







typedef union sigval
  {
    int sival_int;
    void *sival_ptr;
  } sigval_t;
# 51 "/usr/include/bits/siginfo.h" 3 4
typedef struct siginfo
  {
    int si_signo;
    int si_errno;

    int si_code;

    union
      {
 int _pad[((128 / sizeof (int)) - 3)];


 struct
   {
     __pid_t si_pid;
     __uid_t si_uid;
   } _kill;


 struct
   {
     int si_tid;
     int si_overrun;
     sigval_t si_sigval;
   } _timer;


 struct
   {
     __pid_t si_pid;
     __uid_t si_uid;
     sigval_t si_sigval;
   } _rt;


 struct
   {
     __pid_t si_pid;
     __uid_t si_uid;
     int si_status;
     __clock_t si_utime;
     __clock_t si_stime;
   } _sigchld;


 struct
   {
     void *si_addr;
   } _sigfault;


 struct
   {
     long int si_band;
     int si_fd;
   } _sigpoll;
      } _sifields;
  } siginfo_t;
# 129 "/usr/include/bits/siginfo.h" 3 4
enum
{
  SI_ASYNCNL = -60,

  SI_TKILL = -6,

  SI_SIGIO,

  SI_ASYNCIO,

  SI_MESGQ,

  SI_TIMER,

  SI_QUEUE,

  SI_USER,

  SI_KERNEL = 0x80

};



enum
{
  ILL_ILLOPC = 1,

  ILL_ILLOPN,

  ILL_ILLADR,

  ILL_ILLTRP,

  ILL_PRVOPC,

  ILL_PRVREG,

  ILL_COPROC,

  ILL_BADSTK

};


enum
{
  FPE_INTDIV = 1,

  FPE_INTOVF,

  FPE_FLTDIV,

  FPE_FLTOVF,

  FPE_FLTUND,

  FPE_FLTRES,

  FPE_FLTINV,

  FPE_FLTSUB

};


enum
{
  SEGV_MAPERR = 1,

  SEGV_ACCERR

};


enum
{
  BUS_ADRALN = 1,

  BUS_ADRERR,

  BUS_OBJERR

};


enum
{
  TRAP_BRKPT = 1,

  TRAP_TRACE

};


enum
{
  CLD_EXITED = 1,

  CLD_KILLED,

  CLD_DUMPED,

  CLD_TRAPPED,

  CLD_STOPPED,

  CLD_CONTINUED

};


enum
{
  POLL_IN = 1,

  POLL_OUT,

  POLL_MSG,

  POLL_ERR,

  POLL_PRI,

  POLL_HUP

};
# 273 "/usr/include/bits/siginfo.h" 3 4
typedef struct sigevent
  {
    sigval_t sigev_value;
    int sigev_signo;
    int sigev_notify;

    union
      {
 int _pad[((64 / sizeof (int)) - 3)];



 __pid_t _tid;

 struct
   {
     void (*_function) (sigval_t);
     void *_attribute;
   } _sigev_thread;
      } _sigev_un;
  } sigevent_t;






enum
{
  SIGEV_SIGNAL = 0,

  SIGEV_NONE,

  SIGEV_THREAD,


  SIGEV_THREAD_ID = 4

};
# 80 "/usr/include/signal.h" 2 3 4




typedef void (*__sighandler_t) (int);




extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler)
     __attribute__ ((__nothrow__));

extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler)
     __attribute__ ((__nothrow__));







extern __sighandler_t signal (int __sig, __sighandler_t __handler)
     __attribute__ ((__nothrow__));
# 113 "/usr/include/signal.h" 3 4





extern __sighandler_t bsd_signal (int __sig, __sighandler_t __handler)
     __attribute__ ((__nothrow__));






extern int kill (__pid_t __pid, int __sig) __attribute__ ((__nothrow__));






extern int killpg (__pid_t __pgrp, int __sig) __attribute__ ((__nothrow__));




extern int raise (int __sig) __attribute__ ((__nothrow__));




extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)
     __attribute__ ((__nothrow__));
extern int gsignal (int __sig) __attribute__ ((__nothrow__));




extern void psignal (int __sig, __const char *__s);




extern void psiginfo (__const siginfo_t *__pinfo, __const char *__s);
# 168 "/usr/include/signal.h" 3 4
extern int __sigpause (int __sig_or_mask, int __is_sig);
# 177 "/usr/include/signal.h" 3 4
extern int sigpause (int __sig) __asm__ ("__xpg_sigpause");
# 196 "/usr/include/signal.h" 3 4
extern int sigblock (int __mask) __attribute__ ((__nothrow__)) __attribute__ ((__deprecated__));


extern int sigsetmask (int __mask) __attribute__ ((__nothrow__)) __attribute__ ((__deprecated__));


extern int siggetmask (void) __attribute__ ((__nothrow__)) __attribute__ ((__deprecated__));
# 211 "/usr/include/signal.h" 3 4
typedef __sighandler_t sighandler_t;




typedef __sighandler_t sig_t;





extern int sigemptyset (sigset_t *__set) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern int sigfillset (sigset_t *__set) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern int sigaddset (sigset_t *__set, int __signo) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern int sigdelset (sigset_t *__set, int __signo) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern int sigismember (__const sigset_t *__set, int __signo)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));



extern int sigisemptyset (__const sigset_t *__set) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern int sigandset (sigset_t *__set, __const sigset_t *__left,
        __const sigset_t *__right) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2, 3)));


extern int sigorset (sigset_t *__set, __const sigset_t *__left,
       __const sigset_t *__right) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2, 3)));




# 1 "/usr/include/bits/sigaction.h" 1 3 4
# 25 "/usr/include/bits/sigaction.h" 3 4
struct sigaction
  {


    union
      {

 __sighandler_t sa_handler;

 void (*sa_sigaction) (int, siginfo_t *, void *);
      }
    __sigaction_handler;







    __sigset_t sa_mask;


    int sa_flags;


    void (*sa_restorer) (void);
  };
# 253 "/usr/include/signal.h" 2 3 4


extern int sigprocmask (int __how, __const sigset_t *__restrict __set,
   sigset_t *__restrict __oset) __attribute__ ((__nothrow__));






extern int sigsuspend (__const sigset_t *__set) __attribute__ ((__nonnull__ (1)));


extern int sigaction (int __sig, __const struct sigaction *__restrict __act,
        struct sigaction *__restrict __oact) __attribute__ ((__nothrow__));


extern int sigpending (sigset_t *__set) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));






extern int sigwait (__const sigset_t *__restrict __set, int *__restrict __sig)
     __attribute__ ((__nonnull__ (1, 2)));






extern int sigwaitinfo (__const sigset_t *__restrict __set,
   siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1)));






extern int sigtimedwait (__const sigset_t *__restrict __set,
    siginfo_t *__restrict __info,
    __const struct timespec *__restrict __timeout)
     __attribute__ ((__nonnull__ (1)));



extern int sigqueue (__pid_t __pid, int __sig, __const union sigval __val)
     __attribute__ ((__nothrow__));
# 310 "/usr/include/signal.h" 3 4
extern __const char *__const _sys_siglist[65];
extern __const char *__const sys_siglist[65];


struct sigvec
  {
    __sighandler_t sv_handler;
    int sv_mask;

    int sv_flags;

  };
# 334 "/usr/include/signal.h" 3 4
extern int sigvec (int __sig, __const struct sigvec *__vec,
     struct sigvec *__ovec) __attribute__ ((__nothrow__));



# 1 "/usr/include/bits/sigcontext.h" 1 3 4
# 28 "/usr/include/bits/sigcontext.h" 3 4
# 1 "/usr/include/asm/sigcontext.h" 1 3 4
# 9 "/usr/include/asm/sigcontext.h" 3 4
struct sigcontext {
 unsigned long trap_no;
 unsigned long error_code;
 unsigned long oldmask;
 unsigned long arm_r0;
 unsigned long arm_r1;
 unsigned long arm_r2;
 unsigned long arm_r3;
 unsigned long arm_r4;
 unsigned long arm_r5;
 unsigned long arm_r6;
 unsigned long arm_r7;
 unsigned long arm_r8;
 unsigned long arm_r9;
 unsigned long arm_r10;
 unsigned long arm_fp;
 unsigned long arm_ip;
 unsigned long arm_sp;
 unsigned long arm_lr;
 unsigned long arm_pc;
 unsigned long arm_cpsr;
 unsigned long fault_address;
};
# 29 "/usr/include/bits/sigcontext.h" 2 3 4
# 340 "/usr/include/signal.h" 2 3 4


extern int sigreturn (struct sigcontext *__scp) __attribute__ ((__nothrow__));






# 1 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include/stddef.h" 1 3 4
# 350 "/usr/include/signal.h" 2 3 4




extern int siginterrupt (int __sig, int __interrupt) __attribute__ ((__nothrow__));

# 1 "/usr/include/bits/sigstack.h" 1 3 4
# 26 "/usr/include/bits/sigstack.h" 3 4
struct sigstack
  {
    void *ss_sp;
    int ss_onstack;
  };



enum
{
  SS_ONSTACK = 1,

  SS_DISABLE

};
# 50 "/usr/include/bits/sigstack.h" 3 4
typedef struct sigaltstack
  {
    void *ss_sp;
    int ss_flags;
    size_t ss_size;
  } stack_t;
# 357 "/usr/include/signal.h" 2 3 4


# 1 "/usr/include/sys/ucontext.h" 1 3 4
# 25 "/usr/include/sys/ucontext.h" 3 4
# 1 "/usr/include/signal.h" 1 3 4
# 26 "/usr/include/sys/ucontext.h" 2 3 4
# 1 "/usr/include/sys/procfs.h" 1 3 4
# 32 "/usr/include/sys/procfs.h" 3 4
# 1 "/usr/include/sys/time.h" 1 3 4
# 27 "/usr/include/sys/time.h" 3 4
# 1 "/usr/include/time.h" 1 3 4
# 28 "/usr/include/sys/time.h" 2 3 4

# 1 "/usr/include/bits/time.h" 1 3 4
# 30 "/usr/include/sys/time.h" 2 3 4
# 39 "/usr/include/sys/time.h" 3 4

# 57 "/usr/include/sys/time.h" 3 4
struct timezone
  {
    int tz_minuteswest;
    int tz_dsttime;
  };

typedef struct timezone *__restrict __timezone_ptr_t;
# 73 "/usr/include/sys/time.h" 3 4
extern int gettimeofday (struct timeval *__restrict __tv,
    __timezone_ptr_t __tz) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));




extern int settimeofday (__const struct timeval *__tv,
    __const struct timezone *__tz)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));





extern int adjtime (__const struct timeval *__delta,
      struct timeval *__olddelta) __attribute__ ((__nothrow__));




enum __itimer_which
  {

    ITIMER_REAL = 0,


    ITIMER_VIRTUAL = 1,



    ITIMER_PROF = 2

  };



struct itimerval
  {

    struct timeval it_interval;

    struct timeval it_value;
  };




typedef enum __itimer_which __itimer_which_t;






extern int getitimer (__itimer_which_t __which,
        struct itimerval *__value) __attribute__ ((__nothrow__));




extern int setitimer (__itimer_which_t __which,
        __const struct itimerval *__restrict __new,
        struct itimerval *__restrict __old) __attribute__ ((__nothrow__));




extern int utimes (__const char *__file, __const struct timeval __tvp[2])
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));



extern int lutimes (__const char *__file, __const struct timeval __tvp[2])
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern int futimes (int __fd, __const struct timeval __tvp[2]) __attribute__ ((__nothrow__));






extern int futimesat (int __fd, __const char *__file,
        __const struct timeval __tvp[2]) __attribute__ ((__nothrow__));
# 191 "/usr/include/sys/time.h" 3 4

# 33 "/usr/include/sys/procfs.h" 2 3 4

# 1 "/usr/include/sys/user.h" 1 3 4
# 26 "/usr/include/sys/user.h" 3 4
struct user_fpregs
{
  struct fp_reg
  {
    unsigned int sign1:1;
    unsigned int unused:15;
    unsigned int sign2:1;
    unsigned int exponent:14;
    unsigned int j:1;
    unsigned int mantissa1:31;
    unsigned int mantissa0:32;
  } fpregs[8];
  unsigned int fpsr:32;
  unsigned int fpcr:32;
  unsigned char ftype[8];
  unsigned int init_flag;
};

struct user_regs
{
  unsigned long int uregs[18];
};

struct user
{
  struct user_regs regs;
  int u_fpvalid;

  unsigned long int u_tsize;
  unsigned long int u_dsize;
  unsigned long int u_ssize;

  unsigned long start_code;
  unsigned long start_stack;

  long int signal;
  int reserved;
  struct user_regs *u_ar0;

  unsigned long magic;
  char u_comm[32];
  int u_debugreg[8];
  struct user_fpregs u_fp;
  struct user_fpregs *u_fp0;
};
# 35 "/usr/include/sys/procfs.h" 2 3 4




typedef unsigned long elf_greg_t;






typedef elf_greg_t elf_gregset_t[(sizeof (struct user_regs) / sizeof(elf_greg_t))];


typedef struct user_fpregs elf_fpregset_t;


struct elf_siginfo
  {
    int si_signo;
    int si_code;
    int si_errno;
  };
# 66 "/usr/include/sys/procfs.h" 3 4
struct elf_prstatus
  {
    struct elf_siginfo pr_info;
    short int pr_cursig;
    unsigned long int pr_sigpend;
    unsigned long int pr_sighold;
    __pid_t pr_pid;
    __pid_t pr_ppid;
    __pid_t pr_pgrp;
    __pid_t pr_sid;
    struct timeval pr_utime;
    struct timeval pr_stime;
    struct timeval pr_cutime;
    struct timeval pr_cstime;
    elf_gregset_t pr_reg;
    int pr_fpvalid;
  };




struct elf_prpsinfo
  {
    char pr_state;
    char pr_sname;
    char pr_zomb;
    char pr_nice;
    unsigned long int pr_flag;
    unsigned short int pr_uid;
    unsigned short int pr_gid;
    int pr_pid, pr_ppid, pr_pgrp, pr_sid;

    char pr_fname[16];
    char pr_psargs[(80)];
  };






typedef void *psaddr_t;


typedef elf_gregset_t prgregset_t;
typedef elf_fpregset_t prfpregset_t;



typedef __pid_t lwpid_t;


typedef struct elf_prstatus prstatus_t;
typedef struct elf_prpsinfo prpsinfo_t;


# 27 "/usr/include/sys/ucontext.h" 2 3 4



# 1 "/usr/include/bits/sigcontext.h" 1 3 4
# 31 "/usr/include/sys/ucontext.h" 2 3 4

typedef int greg_t;





typedef elf_gregset_t gregset_t;


enum
{
  R0 = 0,

  R1 = 1,

  R2 = 2,

  R3 = 3,

  R4 = 4,

  R5 = 5,

  R6 = 6,

  R7 = 7,

  R8 = 8,

  R9 = 9,

  R10 = 10,

  R11 = 11,

  R12 = 12,

  R13 = 13,

  R14 = 14,

  R15 = 15

};


typedef elf_fpregset_t fpregset_t;





typedef struct sigcontext mcontext_t;


typedef struct ucontext
  {
    unsigned long uc_flags;
    struct ucontext *uc_link;
    stack_t uc_stack;
    mcontext_t uc_mcontext;
    __sigset_t uc_sigmask;
    unsigned long uc_regspace[128] __attribute__((__aligned__(8)));
  } ucontext_t;
# 360 "/usr/include/signal.h" 2 3 4





extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)
     __attribute__ ((__nothrow__)) __attribute__ ((__deprecated__));



extern int sigaltstack (__const struct sigaltstack *__restrict __ss,
   struct sigaltstack *__restrict __oss) __attribute__ ((__nothrow__));







extern int sighold (int __sig) __attribute__ ((__nothrow__));


extern int sigrelse (int __sig) __attribute__ ((__nothrow__));


extern int sigignore (int __sig) __attribute__ ((__nothrow__));


extern __sighandler_t sigset (int __sig, __sighandler_t __disp) __attribute__ ((__nothrow__));






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


extern int pthread_kill (pthread_t __threadid, int __signo) __attribute__ ((__nothrow__));



extern int pthread_sigqueue (pthread_t __threadid, int __signo,
        const union sigval __value) __attribute__ ((__nothrow__));
# 396 "/usr/include/signal.h" 2 3 4






extern int __libc_current_sigrtmin (void) __attribute__ ((__nothrow__));

extern int __libc_current_sigrtmax (void) __attribute__ ((__nothrow__));




# 25 "../../target-i386/translate.c" 2

# 1 "../../target-i386/cpu.h" 1
# 22 "../../target-i386/cpu.h"
# 1 "../../config.h" 1
# 1 "../config-host.h" 1
# 2 "../../config.h" 2
# 1 "./config-target.h" 1
# 2 "../../config.h" 2
# 23 "../../target-i386/cpu.h" 2
# 1 "../../qemu-common.h" 1




# 1 "../config-host.h" 1
# 6 "../../qemu-common.h" 2
# 16 "../../qemu-common.h"
typedef struct QEMUTimer QEMUTimer;
typedef struct QEMUFile QEMUFile;
typedef struct QEMUBH QEMUBH;
typedef struct DeviceState DeviceState;





# 1 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include/stdbool.h" 1 3 4
# 26 "../../qemu-common.h" 2

# 1 "/usr/include/strings.h" 1 3 4
# 28 "../../qemu-common.h" 2

# 1 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include-fixed/limits.h" 1 3 4
# 34 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include-fixed/limits.h" 3 4
# 1 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include-fixed/syslimits.h" 1 3 4






# 1 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include-fixed/limits.h" 1 3 4
# 169 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include-fixed/limits.h" 3 4
# 1 "/usr/include/limits.h" 1 3 4
# 145 "/usr/include/limits.h" 3 4
# 1 "/usr/include/bits/posix1_lim.h" 1 3 4
# 157 "/usr/include/bits/posix1_lim.h" 3 4
# 1 "/usr/include/bits/local_lim.h" 1 3 4
# 39 "/usr/include/bits/local_lim.h" 3 4
# 1 "/usr/include/linux/limits.h" 1 3 4
# 40 "/usr/include/bits/local_lim.h" 2 3 4
# 158 "/usr/include/bits/posix1_lim.h" 2 3 4
# 146 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/posix2_lim.h" 1 3 4
# 150 "/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
# 154 "/usr/include/limits.h" 2 3 4
# 170 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include-fixed/limits.h" 2 3 4
# 8 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include-fixed/syslimits.h" 2 3 4
# 35 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include-fixed/limits.h" 2 3 4
# 30 "../../qemu-common.h" 2
# 1 "/usr/include/time.h" 1 3 4
# 30 "/usr/include/time.h" 3 4








# 1 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include/stddef.h" 1 3 4
# 39 "/usr/include/time.h" 2 3 4



# 1 "/usr/include/bits/time.h" 1 3 4
# 43 "/usr/include/time.h" 2 3 4
# 131 "/usr/include/time.h" 3 4


struct tm
{
  int tm_sec;
  int tm_min;
  int tm_hour;
  int tm_mday;
  int tm_mon;
  int tm_year;
  int tm_wday;
  int tm_yday;
  int tm_isdst;


  long int tm_gmtoff;
  __const char *tm_zone;




};








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


struct sigevent;
# 180 "/usr/include/time.h" 3 4



extern clock_t clock (void) __attribute__ ((__nothrow__));


extern time_t time (time_t *__timer) __attribute__ ((__nothrow__));


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


extern time_t mktime (struct tm *__tp) __attribute__ ((__nothrow__));





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





extern char *strptime (__const char *__restrict __s,
         __const char *__restrict __fmt, struct tm *__tp)
     __attribute__ ((__nothrow__));







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



extern char *strptime_l (__const char *__restrict __s,
    __const char *__restrict __fmt, struct tm *__tp,
    __locale_t __loc) __attribute__ ((__nothrow__));






extern struct tm *gmtime (__const time_t *__timer) __attribute__ ((__nothrow__));



extern struct tm *localtime (__const time_t *__timer) __attribute__ ((__nothrow__));





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



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





extern char *asctime (__const struct tm *__tp) __attribute__ ((__nothrow__));


extern char *ctime (__const time_t *__timer) __attribute__ ((__nothrow__));







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


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




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




extern char *tzname[2];



extern void tzset (void) __attribute__ ((__nothrow__));



extern int daylight;
extern long int timezone;





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


extern time_t timelocal (struct tm *__tp) __attribute__ ((__nothrow__));


extern int dysize (int __year) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
# 328 "/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) __attribute__ ((__nothrow__));


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


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






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




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


extern int timer_delete (timer_t __timerid) __attribute__ ((__nothrow__));


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


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


extern int timer_getoverrun (timer_t __timerid) __attribute__ ((__nothrow__));
# 390 "/usr/include/time.h" 3 4
extern int getdate_err;
# 399 "/usr/include/time.h" 3 4
extern struct tm *getdate (__const char *__string);
# 413 "/usr/include/time.h" 3 4
extern int getdate_r (__const char *__restrict __string,
        struct tm *__restrict __resbufp);



# 31 "../../qemu-common.h" 2
# 1 "/usr/include/ctype.h" 1 3 4
# 30 "/usr/include/ctype.h" 3 4

# 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__ ((__nothrow__)) __attribute__ ((__const));
extern __const __int32_t **__ctype_tolower_loc (void)
     __attribute__ ((__nothrow__)) __attribute__ ((__const));
extern __const __int32_t **__ctype_toupper_loc (void)
     __attribute__ ((__nothrow__)) __attribute__ ((__const));
# 96 "/usr/include/ctype.h" 3 4






extern int isalnum (int) __attribute__ ((__nothrow__));
extern int isalpha (int) __attribute__ ((__nothrow__));
extern int iscntrl (int) __attribute__ ((__nothrow__));
extern int isdigit (int) __attribute__ ((__nothrow__));
extern int islower (int) __attribute__ ((__nothrow__));
extern int isgraph (int) __attribute__ ((__nothrow__));
extern int isprint (int) __attribute__ ((__nothrow__));
extern int ispunct (int) __attribute__ ((__nothrow__));
extern int isspace (int) __attribute__ ((__nothrow__));
extern int isupper (int) __attribute__ ((__nothrow__));
extern int isxdigit (int) __attribute__ ((__nothrow__));



extern int tolower (int __c) __attribute__ ((__nothrow__));


extern int toupper (int __c) __attribute__ ((__nothrow__));








extern int isblank (int) __attribute__ ((__nothrow__));






extern int isctype (int __c, int __mask) __attribute__ ((__nothrow__));






extern int isascii (int __c) __attribute__ ((__nothrow__));



extern int toascii (int __c) __attribute__ ((__nothrow__));



extern int _toupper (int) __attribute__ ((__nothrow__));
extern int _tolower (int) __attribute__ ((__nothrow__));
# 190 "/usr/include/ctype.h" 3 4
extern __inline int
__attribute__ ((__nothrow__)) tolower (int __c)
{
  return __c >= -128 && __c < 256 ? (*__ctype_tolower_loc ())[__c] : __c;
}

extern __inline int
__attribute__ ((__nothrow__)) toupper (int __c)
{
  return __c >= -128 && __c < 256 ? (*__ctype_toupper_loc ())[__c] : __c;
}
# 247 "/usr/include/ctype.h" 3 4
extern int isalnum_l (int, __locale_t) __attribute__ ((__nothrow__));
extern int isalpha_l (int, __locale_t) __attribute__ ((__nothrow__));
extern int iscntrl_l (int, __locale_t) __attribute__ ((__nothrow__));
extern int isdigit_l (int, __locale_t) __attribute__ ((__nothrow__));
extern int islower_l (int, __locale_t) __attribute__ ((__nothrow__));
extern int isgraph_l (int, __locale_t) __attribute__ ((__nothrow__));
extern int isprint_l (int, __locale_t) __attribute__ ((__nothrow__));
extern int ispunct_l (int, __locale_t) __attribute__ ((__nothrow__));
extern int isspace_l (int, __locale_t) __attribute__ ((__nothrow__));
extern int isupper_l (int, __locale_t) __attribute__ ((__nothrow__));
extern int isxdigit_l (int, __locale_t) __attribute__ ((__nothrow__));

extern int isblank_l (int, __locale_t) __attribute__ ((__nothrow__));



extern int __tolower_l (int __c, __locale_t __l) __attribute__ ((__nothrow__));
extern int tolower_l (int __c, __locale_t __l) __attribute__ ((__nothrow__));


extern int __toupper_l (int __c, __locale_t __l) __attribute__ ((__nothrow__));
extern int toupper_l (int __c, __locale_t __l) __attribute__ ((__nothrow__));
# 323 "/usr/include/ctype.h" 3 4

# 32 "../../qemu-common.h" 2
# 1 "/usr/include/errno.h" 1 3 4
# 32 "/usr/include/errno.h" 3 4




# 1 "/usr/include/bits/errno.h" 1 3 4
# 25 "/usr/include/bits/errno.h" 3 4
# 1 "/usr/include/linux/errno.h" 1 3 4



# 1 "/usr/include/asm/errno.h" 1 3 4



# 1 "/usr/include/asm-generic/errno.h" 1 3 4



# 1 "/usr/include/asm-generic/errno-base.h" 1 3 4
# 5 "/usr/include/asm-generic/errno.h" 2 3 4
# 5 "/usr/include/asm/errno.h" 2 3 4
# 5 "/usr/include/linux/errno.h" 2 3 4
# 26 "/usr/include/bits/errno.h" 2 3 4
# 47 "/usr/include/bits/errno.h" 3 4
extern int *__errno_location (void) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
# 37 "/usr/include/errno.h" 2 3 4
# 55 "/usr/include/errno.h" 3 4
extern char *program_invocation_name, *program_invocation_short_name;




# 69 "/usr/include/errno.h" 3 4
typedef int error_t;
# 33 "../../qemu-common.h" 2
# 1 "/usr/include/unistd.h" 1 3 4
# 28 "/usr/include/unistd.h" 3 4

# 203 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/bits/posix_opt.h" 1 3 4
# 204 "/usr/include/unistd.h" 2 3 4



# 1 "/usr/include/bits/environments.h" 1 3 4
# 23 "/usr/include/bits/environments.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 24 "/usr/include/bits/environments.h" 2 3 4
# 208 "/usr/include/unistd.h" 2 3 4
# 227 "/usr/include/unistd.h" 3 4
# 1 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include/stddef.h" 1 3 4
# 228 "/usr/include/unistd.h" 2 3 4
# 275 "/usr/include/unistd.h" 3 4
typedef __socklen_t socklen_t;
# 288 "/usr/include/unistd.h" 3 4
extern int access (__const char *__name, int __type) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));




extern int euidaccess (__const char *__name, int __type)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern int eaccess (__const char *__name, int __type)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));






extern int faccessat (int __fd, __const char *__file, int __type, int __flag)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
# 334 "/usr/include/unistd.h" 3 4
extern __off64_t lseek (int __fd, __off64_t __offset, int __whence) __asm__ ("" "lseek64") __attribute__ ((__nothrow__))

             ;





extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
     __attribute__ ((__nothrow__));






extern int close (int __fd);






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





extern ssize_t write (int __fd, __const void *__buf, size_t __n) __attribute__ ((__warn_unused_result__));
# 385 "/usr/include/unistd.h" 3 4
extern ssize_t pread (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pread64")

               __attribute__ ((__warn_unused_result__));
extern ssize_t pwrite (int __fd, __const void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pwrite64")

                __attribute__ ((__warn_unused_result__));
# 401 "/usr/include/unistd.h" 3 4
extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
   __off64_t __offset) __attribute__ ((__warn_unused_result__));


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







extern int pipe (int __pipedes[2]) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));




extern int pipe2 (int __pipedes[2], int __flags) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));
# 429 "/usr/include/unistd.h" 3 4
extern unsigned int alarm (unsigned int __seconds) __attribute__ ((__nothrow__));
# 441 "/usr/include/unistd.h" 3 4
extern unsigned int sleep (unsigned int __seconds);







extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
     __attribute__ ((__nothrow__));






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



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



extern int fchown (int __fd, __uid_t __owner, __gid_t __group) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));




extern int lchown (__const char *__file, __uid_t __owner, __gid_t __group)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));






extern int fchownat (int __fd, __const char *__file, __uid_t __owner,
       __gid_t __group, int __flag)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));



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



extern int fchdir (int __fd) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));
# 508 "/usr/include/unistd.h" 3 4
extern char *getcwd (char *__buf, size_t __size) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));





extern char *get_current_dir_name (void) __attribute__ ((__nothrow__));







extern char *getwd (char *__buf)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) __attribute__ ((__warn_unused_result__));




extern int dup (int __fd) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));


extern int dup2 (int __fd, int __fd2) __attribute__ ((__nothrow__));




extern int dup3 (int __fd, int __fd2, int __flags) __attribute__ ((__nothrow__));



extern char **__environ;

extern char **environ;





extern int execve (__const char *__path, char *__const __argv[],
     char *__const __envp[]) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));




extern int fexecve (int __fd, char *__const __argv[], char *__const __envp[])
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));




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



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



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



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




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




extern int execvpe (__const char *__file, char *__const __argv[],
      char *__const __envp[])
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));





extern int nice (int __inc) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));




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,


    _SC_V7_ILP32_OFF32,

    _SC_V7_ILP32_OFFBIG,

    _SC_V7_LP64_OFF64,

    _SC_V7_LPBIG_OFFBIG,


    _SC_SS_REPL_MAX,


    _SC_TRACE_EVENT_NAME_MAX,

    _SC_TRACE_NAME_MAX,

    _SC_TRACE_SYS_MAX,

    _SC_TRACE_USER_EVENT_MAX,


    _SC_XOPEN_STREAMS,


    _SC_THREAD_ROBUST_PRIO_INHERIT,

    _SC_THREAD_ROBUST_PRIO_PROTECT

  };


enum
  {
    _CS_PATH,


    _CS_V6_WIDTH_RESTRICTED_ENVS,



    _CS_GNU_LIBC_VERSION,

    _CS_GNU_LIBPTHREAD_VERSION,


    _CS_V5_WIDTH_RESTRICTED_ENVS,



    _CS_V7_WIDTH_RESTRICTED_ENVS,



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


    _CS_POSIX_V7_ILP32_OFF32_CFLAGS,

    _CS_POSIX_V7_ILP32_OFF32_LDFLAGS,

    _CS_POSIX_V7_ILP32_OFF32_LIBS,

    _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,

    _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,

    _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,

    _CS_POSIX_V7_ILP32_OFFBIG_LIBS,

    _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,

    _CS_POSIX_V7_LP64_OFF64_CFLAGS,

    _CS_POSIX_V7_LP64_OFF64_LDFLAGS,

    _CS_POSIX_V7_LP64_OFF64_LIBS,

    _CS_POSIX_V7_LP64_OFF64_LINTFLAGS,

    _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,

    _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,

    _CS_POSIX_V7_LPBIG_OFFBIG_LIBS,

    _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS,


    _CS_V6_ENV,

    _CS_V7_ENV

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


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


extern long int fpathconf (int __fd, int __name) __attribute__ ((__nothrow__));


extern long int sysconf (int __name) __attribute__ ((__nothrow__));



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




extern __pid_t getpid (void) __attribute__ ((__nothrow__));


extern __pid_t getppid (void) __attribute__ ((__nothrow__));




extern __pid_t getpgrp (void) __attribute__ ((__nothrow__));
# 643 "/usr/include/unistd.h" 3 4
extern __pid_t __getpgid (__pid_t __pid) __attribute__ ((__nothrow__));

extern __pid_t getpgid (__pid_t __pid) __attribute__ ((__nothrow__));






extern int setpgid (__pid_t __pid, __pid_t __pgid) __attribute__ ((__nothrow__));
# 669 "/usr/include/unistd.h" 3 4
extern int setpgrp (void) __attribute__ ((__nothrow__));
# 686 "/usr/include/unistd.h" 3 4
extern __pid_t setsid (void) __attribute__ ((__nothrow__));



extern __pid_t getsid (__pid_t __pid) __attribute__ ((__nothrow__));



extern __uid_t getuid (void) __attribute__ ((__nothrow__));


extern __uid_t geteuid (void) __attribute__ ((__nothrow__));


extern __gid_t getgid (void) __attribute__ ((__nothrow__));


extern __gid_t getegid (void) __attribute__ ((__nothrow__));




extern int getgroups (int __size, __gid_t __list[]) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));



extern int group_member (__gid_t __gid) __attribute__ ((__nothrow__));






extern int setuid (__uid_t __uid) __attribute__ ((__nothrow__));




extern int setreuid (__uid_t __ruid, __uid_t __euid) __attribute__ ((__nothrow__));




extern int seteuid (__uid_t __uid) __attribute__ ((__nothrow__));






extern int setgid (__gid_t __gid) __attribute__ ((__nothrow__));




extern int setregid (__gid_t __rgid, __gid_t __egid) __attribute__ ((__nothrow__));




extern int setegid (__gid_t __gid) __attribute__ ((__nothrow__));





extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
     __attribute__ ((__nothrow__));



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



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



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






extern __pid_t fork (void) __attribute__ ((__nothrow__));







extern __pid_t vfork (void) __attribute__ ((__nothrow__));





extern char *ttyname (int __fd) __attribute__ ((__nothrow__));



extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));



extern int isatty (int __fd) __attribute__ ((__nothrow__));





extern int ttyslot (void) __attribute__ ((__nothrow__));




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




extern int linkat (int __fromfd, __const char *__from, int __tofd,
     __const char *__to, int __flags)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 4))) __attribute__ ((__warn_unused_result__));




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




extern ssize_t readlink (__const char *__restrict __path,
    char *__restrict __buf, size_t __len)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));




extern int symlinkat (__const char *__from, int __tofd,
        __const char *__to) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 3))) __attribute__ ((__warn_unused_result__));


extern ssize_t readlinkat (int __fd, __const char *__restrict __path,
      char *__restrict __buf, size_t __len)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));



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



extern int unlinkat (int __fd, __const char *__name, int __flag)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));



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



extern __pid_t tcgetpgrp (int __fd) __attribute__ ((__nothrow__));


extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) __attribute__ ((__nothrow__));






extern char *getlogin (void);







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




extern int setlogin (__const char *__name) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
# 890 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/getopt.h" 1 3 4
# 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)
       __attribute__ ((__nothrow__));
# 891 "/usr/include/unistd.h" 2 3 4







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






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



extern int sethostid (long int __id) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));





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





extern int vhangup (void) __attribute__ ((__nothrow__));


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







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





extern int acct (__const char *__name) __attribute__ ((__nothrow__));



extern char *getusershell (void) __attribute__ ((__nothrow__));
extern void endusershell (void) __attribute__ ((__nothrow__));
extern void setusershell (void) __attribute__ ((__nothrow__));





extern int daemon (int __nochdir, int __noclose) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));






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



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






extern long int gethostid (void);


extern void sync (void) __attribute__ ((__nothrow__));





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




extern int getdtablesize (void) __attribute__ ((__nothrow__));
# 1011 "/usr/include/unistd.h" 3 4
extern int truncate (__const char *__file, __off64_t __length) __asm__ ("" "truncate64") __attribute__ ((__nothrow__))

                  __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));





extern int truncate64 (__const char *__file, __off64_t __length)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 1029 "/usr/include/unistd.h" 3 4
extern int ftruncate (int __fd, __off64_t __length) __asm__ ("" "ftruncate64") __attribute__ ((__nothrow__))
                   __attribute__ ((__warn_unused_result__));





extern int ftruncate64 (int __fd, __off64_t __length) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));
# 1047 "/usr/include/unistd.h" 3 4
extern int brk (void *__addr) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));





extern void *sbrk (intptr_t __delta) __attribute__ ((__nothrow__));
# 1068 "/usr/include/unistd.h" 3 4
extern long int syscall (long int __sysno, ...) __attribute__ ((__nothrow__));
# 1094 "/usr/include/unistd.h" 3 4
extern int lockf (int __fd, int __cmd, __off64_t __len) __asm__ ("" "lockf64")
                  __attribute__ ((__warn_unused_result__));





extern int lockf64 (int __fd, int __cmd, __off64_t __len) __attribute__ ((__warn_unused_result__));
# 1122 "/usr/include/unistd.h" 3 4
extern int fdatasync (int __fildes);







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



extern void encrypt (char *__libc_block, int __edflag) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));






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







extern char *ctermid (char *__s) __attribute__ ((__nothrow__));





# 1 "/usr/include/bits/unistd.h" 1 3 4
# 24 "/usr/include/bits/unistd.h" 3 4
extern ssize_t __read_chk (int __fd, void *__buf, size_t __nbytes,
      size_t __buflen) __attribute__ ((__warn_unused_result__));
extern ssize_t __read_alias (int __fd, void *__buf, size_t __nbytes) __asm__ ("" "read")
                               __attribute__ ((__warn_unused_result__));
extern ssize_t __read_chk_warn (int __fd, void *__buf, size_t __nbytes, size_t __buflen) __asm__ ("" "__read_chk")


     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("read called with bigger length than size of " "the destination buffer")))
                                  ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
read (int __fd, void *__buf, size_t __nbytes)
{
  if (__builtin_object_size (__buf, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__nbytes))
 return __read_chk (__fd, __buf, __nbytes, __builtin_object_size (__buf, 0));

      if (__nbytes > __builtin_object_size (__buf, 0))
 return __read_chk_warn (__fd, __buf, __nbytes, __builtin_object_size (__buf, 0));
    }
  return __read_alias (__fd, __buf, __nbytes);
}


extern ssize_t __pread_chk (int __fd, void *__buf, size_t __nbytes,
       __off_t __offset, size_t __bufsize) __attribute__ ((__warn_unused_result__));
extern ssize_t __pread64_chk (int __fd, void *__buf, size_t __nbytes,
         __off64_t __offset, size_t __bufsize) __attribute__ ((__warn_unused_result__));
extern ssize_t __pread_alias (int __fd, void *__buf, size_t __nbytes, __off_t __offset) __asm__ ("" "pread")

                                 __attribute__ ((__warn_unused_result__));
extern ssize_t __pread64_alias (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pread64")

                                     __attribute__ ((__warn_unused_result__));
extern ssize_t __pread_chk_warn (int __fd, void *__buf, size_t __nbytes, __off_t __offset, size_t __bufsize) __asm__ ("" "__pread_chk")


     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("pread called with bigger length than size of " "the destination buffer")))
                                  ;
extern ssize_t __pread64_chk_warn (int __fd, void *__buf, size_t __nbytes, __off64_t __offset, size_t __bufsize) __asm__ ("" "__pread64_chk")



     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("pread64 called with bigger length than size of " "the destination buffer")))
                                  ;
# 87 "/usr/include/bits/unistd.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
pread (int __fd, void *__buf, size_t __nbytes, __off64_t __offset)
{
  if (__builtin_object_size (__buf, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__nbytes))
 return __pread64_chk (__fd, __buf, __nbytes, __offset, __builtin_object_size (__buf, 0));

      if ( __nbytes > __builtin_object_size (__buf, 0))
 return __pread64_chk_warn (__fd, __buf, __nbytes, __offset,
       __builtin_object_size (__buf, 0));
    }

  return __pread64_alias (__fd, __buf, __nbytes, __offset);
}



extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
pread64 (int __fd, void *__buf, size_t __nbytes, __off64_t __offset)
{
  if (__builtin_object_size (__buf, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__nbytes))
 return __pread64_chk (__fd, __buf, __nbytes, __offset, __builtin_object_size (__buf, 0));

      if ( __nbytes > __builtin_object_size (__buf, 0))
 return __pread64_chk_warn (__fd, __buf, __nbytes, __offset,
       __builtin_object_size (__buf, 0));
    }

  return __pread64_alias (__fd, __buf, __nbytes, __offset);
}




extern ssize_t __readlink_chk (__const char *__restrict __path,
          char *__restrict __buf, size_t __len,
          size_t __buflen)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
extern ssize_t __readlink_alias (__const char *__restrict __path, char *__restrict __buf, size_t __len) __asm__ ("" "readlink") __attribute__ ((__nothrow__))


     __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
extern ssize_t __readlink_chk_warn (__const char *__restrict __path, char *__restrict __buf, size_t __len, size_t __buflen) __asm__ ("" "__readlink_chk") __attribute__ ((__nothrow__))



     __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("readlink called with bigger length " "than size of destination buffer")))
                                         ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__)) ssize_t
__attribute__ ((__nothrow__)) readlink (__const char *__restrict __path, char *__restrict __buf, size_t __len)

{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
 return __readlink_chk (__path, __buf, __len, __builtin_object_size (__buf, 2 > 1));

      if ( __len > __builtin_object_size (__buf, 2 > 1))
 return __readlink_chk_warn (__path, __buf, __len, __builtin_object_size (__buf, 2 > 1));
    }
  return __readlink_alias (__path, __buf, __len);
}



extern ssize_t __readlinkat_chk (int __fd, __const char *__restrict __path,
     char *__restrict __buf, size_t __len,
     size_t __buflen)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
extern ssize_t __readlinkat_alias (int __fd, __const char *__restrict __path, char *__restrict __buf, size_t __len) __asm__ ("" "readlinkat") __attribute__ ((__nothrow__))



     __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
extern ssize_t __readlinkat_chk_warn (int __fd, __const char *__restrict __path, char *__restrict __buf, size_t __len, size_t __buflen) __asm__ ("" "__readlinkat_chk") __attribute__ ((__nothrow__))



     __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("readlinkat called with bigger " "length than size of destination " "buffer")))

                ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__)) ssize_t
__attribute__ ((__nothrow__)) readlinkat (int __fd, __const char *__restrict __path, char *__restrict __buf, size_t __len)

{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
 return __readlinkat_chk (__fd, __path, __buf, __len, __builtin_object_size (__buf, 2 > 1));

      if (__len > __builtin_object_size (__buf, 2 > 1))
 return __readlinkat_chk_warn (__fd, __path, __buf, __len,
          __builtin_object_size (__buf, 2 > 1));
    }
  return __readlinkat_alias (__fd, __path, __buf, __len);
}


extern char *__getcwd_chk (char *__buf, size_t __size, size_t __buflen)
     __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));
extern char *__getcwd_alias (char *__buf, size_t __size) __asm__ ("" "getcwd") __attribute__ ((__nothrow__))
                                              __attribute__ ((__warn_unused_result__));
extern char *__getcwd_chk_warn (char *__buf, size_t __size, size_t __buflen) __asm__ ("" "__getcwd_chk") __attribute__ ((__nothrow__))


     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getcwd caller with bigger length than size of " "destination buffer")))
                              ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
__attribute__ ((__nothrow__)) getcwd (char *__buf, size_t __size)
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__size))
 return __getcwd_chk (__buf, __size, __builtin_object_size (__buf, 2 > 1));

      if (__size > __builtin_object_size (__buf, 2 > 1))
 return __getcwd_chk_warn (__buf, __size, __builtin_object_size (__buf, 2 > 1));
    }
  return __getcwd_alias (__buf, __size);
}


extern char *__getwd_chk (char *__buf, size_t buflen)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern char *__getwd_warn (char *__buf) __asm__ ("" "getwd") __attribute__ ((__nothrow__))
     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("please use getcwd instead, as getwd " "doesn't specify buffer size")))
                                         ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) __attribute__ ((__warn_unused_result__)) char *
__attribute__ ((__nothrow__)) getwd (char *__buf)
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    return __getwd_chk (__buf, __builtin_object_size (__buf, 2 > 1));
  return __getwd_warn (__buf);
}


extern size_t __confstr_chk (int __name, char *__buf, size_t __len,
        size_t __buflen) __attribute__ ((__nothrow__));
extern size_t __confstr_alias (int __name, char *__buf, size_t __len) __asm__ ("" "confstr") __attribute__ ((__nothrow__))
                             ;
extern size_t __confstr_chk_warn (int __name, char *__buf, size_t __len, size_t __buflen) __asm__ ("" "__confstr_chk") __attribute__ ((__nothrow__))


     __attribute__((__warning__ ("confstr called with bigger length than size of destination " "buffer")))
            ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) size_t
__attribute__ ((__nothrow__)) confstr (int __name, char *__buf, size_t __len)
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
 return __confstr_chk (__name, __buf, __len, __builtin_object_size (__buf, 2 > 1));

      if (__builtin_object_size (__buf, 2 > 1) < __len)
 return __confstr_chk_warn (__name, __buf, __len, __builtin_object_size (__buf, 2 > 1));
    }
  return __confstr_alias (__name, __buf, __len);
}


extern int __getgroups_chk (int __size, __gid_t __list[], size_t __listlen)
     __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));
extern int __getgroups_alias (int __size, __gid_t __list[]) __asm__ ("" "getgroups") __attribute__ ((__nothrow__))
                 __attribute__ ((__warn_unused_result__));
extern int __getgroups_chk_warn (int __size, __gid_t __list[], size_t __listlen) __asm__ ("" "__getgroups_chk") __attribute__ ((__nothrow__))


     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getgroups called with bigger group count than what " "can fit into destination buffer")))
                                           ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__nothrow__)) getgroups (int __size, __gid_t __list[])
{
  if (__builtin_object_size (__list, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__size) || __size < 0)
 return __getgroups_chk (__size, __list, __builtin_object_size (__list, 2 > 1));

      if (__size * sizeof (__gid_t) > __builtin_object_size (__list, 2 > 1))
 return __getgroups_chk_warn (__size, __list, __builtin_object_size (__list, 2 > 1));
    }
  return __getgroups_alias (__size, __list);
}


extern int __ttyname_r_chk (int __fd, char *__buf, size_t __buflen,
       size_t __nreal) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
extern int __ttyname_r_alias (int __fd, char *__buf, size_t __buflen) __asm__ ("" "ttyname_r") __attribute__ ((__nothrow__))

     __attribute__ ((__nonnull__ (2)));
extern int __ttyname_r_chk_warn (int __fd, char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__ttyname_r_chk") __attribute__ ((__nothrow__))


     __attribute__ ((__nonnull__ (2))) __attribute__((__warning__ ("ttyname_r called with bigger buflen than " "size of destination buffer")))
                                  ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__nothrow__)) ttyname_r (int __fd, char *__buf, size_t __buflen)
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__buflen))
 return __ttyname_r_chk (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));

      if (__buflen > __builtin_object_size (__buf, 2 > 1))
 return __ttyname_r_chk_warn (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
    }
  return __ttyname_r_alias (__fd, __buf, __buflen);
}



extern int __getlogin_r_chk (char *__buf, size_t __buflen, size_t __nreal)
     __attribute__ ((__nonnull__ (1)));
extern int __getlogin_r_alias (char *__buf, size_t __buflen) __asm__ ("" "getlogin_r")
                     __attribute__ ((__nonnull__ (1)));
extern int __getlogin_r_chk_warn (char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__getlogin_r_chk")


     __attribute__ ((__nonnull__ (1))) __attribute__((__warning__ ("getlogin_r called with bigger buflen than " "size of destination buffer")))
                                  ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
getlogin_r (char *__buf, size_t __buflen)
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__buflen))
 return __getlogin_r_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));

      if (__buflen > __builtin_object_size (__buf, 2 > 1))
 return __getlogin_r_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
    }
  return __getlogin_r_alias (__buf, __buflen);
}




extern int __gethostname_chk (char *__buf, size_t __buflen, size_t __nreal)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
extern int __gethostname_alias (char *__buf, size_t __buflen) __asm__ ("" "gethostname") __attribute__ ((__nothrow__))
                   __attribute__ ((__nonnull__ (1)));
extern int __gethostname_chk_warn (char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__gethostname_chk") __attribute__ ((__nothrow__))


     __attribute__ ((__nonnull__ (1))) __attribute__((__warning__ ("gethostname called with bigger buflen than " "size of destination buffer")))
                                  ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__nothrow__)) gethostname (char *__buf, size_t __buflen)
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__buflen))
 return __gethostname_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));

      if (__buflen > __builtin_object_size (__buf, 2 > 1))
 return __gethostname_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
    }
  return __gethostname_alias (__buf, __buflen);
}




extern int __getdomainname_chk (char *__buf, size_t __buflen, size_t __nreal)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int __getdomainname_alias (char *__buf, size_t __buflen) __asm__ ("" "getdomainname") __attribute__ ((__nothrow__))

                     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int __getdomainname_chk_warn (char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__getdomainname_chk") __attribute__ ((__nothrow__))


     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getdomainname called with bigger " "buflen than size of destination " "buffer")))

                    ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__nothrow__)) getdomainname (char *__buf, size_t __buflen)
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__buflen))
 return __getdomainname_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));

      if (__buflen > __builtin_object_size (__buf, 2 > 1))
 return __getdomainname_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
    }
  return __getdomainname_alias (__buf, __buflen);
}
# 1158 "/usr/include/unistd.h" 2 3 4



# 34 "../../qemu-common.h" 2
# 1 "/usr/include/fcntl.h" 1 3 4
# 30 "/usr/include/fcntl.h" 3 4




# 1 "/usr/include/bits/fcntl.h" 1 3 4
# 27 "/usr/include/bits/fcntl.h" 3 4
# 1 "/usr/include/bits/uio.h" 1 3 4
# 44 "/usr/include/bits/uio.h" 3 4
struct iovec
  {
    void *iov_base;
    size_t iov_len;
  };
# 28 "/usr/include/bits/fcntl.h" 2 3 4
# 150 "/usr/include/bits/fcntl.h" 3 4
struct flock
  {
    short int l_type;
    short int l_whence;




    __off64_t l_start;
    __off64_t l_len;

    __pid_t l_pid;
  };


struct flock64
  {
    short int l_type;
    short int l_whence;
    __off64_t l_start;
    __off64_t l_len;
    __pid_t l_pid;
  };




enum __pid_type
  {
    F_OWNER_TID = 0,
    F_OWNER_PID,
    F_OWNER_PGRP,
    F_OWNER_GID = F_OWNER_PGRP
  };


struct f_owner_ex
  {
    enum __pid_type type;
    __pid_t pid;
  };
# 248 "/usr/include/bits/fcntl.h" 3 4





extern ssize_t readahead (int __fd, __off64_t __offset, size_t __count)
    __attribute__ ((__nothrow__));



extern int sync_file_range (int __fd, __off64_t __offset, __off64_t __count,
       unsigned int __flags);



extern ssize_t vmsplice (int __fdout, const struct iovec *__iov,
    size_t __count, unsigned int __flags);


extern ssize_t splice (int __fdin, __off64_t *__offin, int __fdout,
         __off64_t *__offout, size_t __len,
         unsigned int __flags);


extern ssize_t tee (int __fdin, int __fdout, size_t __len,
      unsigned int __flags);






extern int fallocate (int __fd, int __mode, __off64_t __offset, __off64_t __len) __asm__ ("" "fallocate64")

                     ;





extern int fallocate64 (int __fd, int __mode, __off64_t __offset,
   __off64_t __len);





# 35 "/usr/include/fcntl.h" 2 3 4






# 1 "/usr/include/bits/stat.h" 1 3 4
# 39 "/usr/include/bits/stat.h" 3 4
struct stat
  {
    __dev_t st_dev;
    unsigned short int __pad1;



    __ino_t __st_ino;

    __mode_t st_mode;
    __nlink_t st_nlink;
    __uid_t st_uid;
    __gid_t st_gid;
    __dev_t st_rdev;
    unsigned short int __pad2;



    __off64_t st_size;

    __blksize_t st_blksize;




    __blkcnt64_t st_blocks;
# 73 "/usr/include/bits/stat.h" 3 4
    struct timespec st_atim;
    struct timespec st_mtim;
    struct timespec st_ctim;
# 91 "/usr/include/bits/stat.h" 3 4
    __ino64_t st_ino;

  };


struct stat64
  {
    __dev_t st_dev;
    unsigned int __pad1;

    __ino_t __st_ino;
    __mode_t st_mode;
    __nlink_t st_nlink;
    __uid_t st_uid;
    __gid_t st_gid;
    __dev_t st_rdev;
    unsigned int __pad2;
    __off64_t st_size;
    __blksize_t st_blksize;

    __blkcnt64_t st_blocks;







    struct timespec st_atim;
    struct timespec st_mtim;
    struct timespec st_ctim;
# 130 "/usr/include/bits/stat.h" 3 4
    __ino64_t st_ino;
  };
# 42 "/usr/include/fcntl.h" 2 3 4
# 110 "/usr/include/fcntl.h" 3 4
extern int fcntl (int __fd, int __cmd, ...);
# 122 "/usr/include/fcntl.h" 3 4
extern int open (__const char *__file, int __oflag, ...) __asm__ ("" "open64")
     __attribute__ ((__nonnull__ (1)));





extern int open64 (__const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
# 147 "/usr/include/fcntl.h" 3 4
extern int openat (int __fd, __const char *__file, int __oflag, ...) __asm__ ("" "openat64")
                    __attribute__ ((__nonnull__ (2)));





extern int openat64 (int __fd, __const char *__file, int __oflag, ...)
     __attribute__ ((__nonnull__ (2)));
# 168 "/usr/include/fcntl.h" 3 4
extern int creat (__const char *__file, __mode_t __mode) __asm__ ("" "creat64")
                  __attribute__ ((__nonnull__ (1)));





extern int creat64 (__const char *__file, __mode_t __mode) __attribute__ ((__nonnull__ (1)));
# 215 "/usr/include/fcntl.h" 3 4
extern int posix_fadvise (int __fd, __off64_t __offset, __off64_t __len, int __advise) __asm__ ("" "posix_fadvise64") __attribute__ ((__nothrow__))

                      ;





extern int posix_fadvise64 (int __fd, __off64_t __offset, __off64_t __len,
       int __advise) __attribute__ ((__nothrow__));
# 236 "/usr/include/fcntl.h" 3 4
extern int posix_fallocate (int __fd, __off64_t __offset, __off64_t __len) __asm__ ("" "posix_fallocate64")

                           ;





extern int posix_fallocate64 (int __fd, __off64_t __offset, __off64_t __len);







# 1 "/usr/include/bits/fcntl2.h" 1 3 4
# 31 "/usr/include/bits/fcntl2.h" 3 4
extern int __open_2 (__const char *__path, int __oflag) __asm__ ("" "__open64_2")
                     __attribute__ ((__nonnull__ (1)));
extern int __open_alias (__const char *__path, int __oflag, ...) __asm__ ("" "open64")
                 __attribute__ ((__nonnull__ (1)));

extern void __open_too_many_args (void) __attribute__((__error__ ("open can be called either with 2 or 3 arguments, not more")))
                                                                  ;
extern void __open_missing_mode (void) __attribute__((__error__ ("open with O_CREAT in second argument needs 3 arguments")))
                                                               ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
open (__const char *__path, int __oflag, ...)
{
  if (__builtin_va_arg_pack_len () > 1)
    __open_too_many_args ();

  if (__builtin_constant_p (__oflag))
    {
      if ((__oflag & 0100) != 0 && __builtin_va_arg_pack_len () < 1)
 {
   __open_missing_mode ();
   return __open_2 (__path, __oflag);
 }
      return __open_alias (__path, __oflag, __builtin_va_arg_pack ());
    }

  if (__builtin_va_arg_pack_len () < 1)
    return __open_2 (__path, __oflag);

  return __open_alias (__path, __oflag, __builtin_va_arg_pack ());
}



extern int __open64_2 (__const char *__path, int __oflag) __attribute__ ((__nonnull__ (1)));
extern int __open64_alias (__const char *__path, int __oflag, ...) __asm__ ("" "open64")
                   __attribute__ ((__nonnull__ (1)));
extern void __open64_too_many_args (void) __attribute__((__error__ ("open64 can be called either with 2 or 3 arguments, not more")))
                                                                    ;
extern void __open64_missing_mode (void) __attribute__((__error__ ("open64 with O_CREAT in second argument needs 3 arguments")))
                                                                 ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
open64 (__const char *__path, int __oflag, ...)
{
  if (__builtin_va_arg_pack_len () > 1)
    __open64_too_many_args ();

  if (__builtin_constant_p (__oflag))
    {
      if ((__oflag & 0100) != 0 && __builtin_va_arg_pack_len () < 1)
 {
   __open64_missing_mode ();
   return __open64_2 (__path, __oflag);
 }
      return __open64_alias (__path, __oflag, __builtin_va_arg_pack ());
    }

  if (__builtin_va_arg_pack_len () < 1)
    return __open64_2 (__path, __oflag);

  return __open64_alias (__path, __oflag, __builtin_va_arg_pack ());
}
# 105 "/usr/include/bits/fcntl2.h" 3 4
extern int __openat_2 (int __fd, __const char *__path, int __oflag) __asm__ ("" "__openat64_2")

     __attribute__ ((__nonnull__ (2)));
extern int __openat_alias (int __fd, __const char *__path, int __oflag, ...) __asm__ ("" "openat64")

     __attribute__ ((__nonnull__ (2)));

extern void __openat_too_many_args (void) __attribute__((__error__ ("openat can be called either with 3 or 4 arguments, not more")))
                                                                    ;
extern void __openat_missing_mode (void) __attribute__((__error__ ("openat with O_CREAT in third argument needs 4 arguments")))
                                                                ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
openat (int __fd, __const char *__path, int __oflag, ...)
{
  if (__builtin_va_arg_pack_len () > 1)
    __openat_too_many_args ();

  if (__builtin_constant_p (__oflag))
    {
      if ((__oflag & 0100) != 0 && __builtin_va_arg_pack_len () < 1)
 {
   __openat_missing_mode ();
   return __openat_2 (__fd, __path, __oflag);
 }
      return __openat_alias (__fd, __path, __oflag, __builtin_va_arg_pack ());
    }

  if (__builtin_va_arg_pack_len () < 1)
    return __openat_2 (__fd, __path, __oflag);

  return __openat_alias (__fd, __path, __oflag, __builtin_va_arg_pack ());
}



extern int __openat64_2 (int __fd, __const char *__path, int __oflag)
     __attribute__ ((__nonnull__ (2)));
extern int __openat64_alias (int __fd, __const char *__path, int __oflag, ...) __asm__ ("" "openat64")

     __attribute__ ((__nonnull__ (2)));
extern void __openat64_too_many_args (void) __attribute__((__error__ ("openat64 can be called either with 3 or 4 arguments, not more")))
                                                                      ;
extern void __openat64_missing_mode (void) __attribute__((__error__ ("openat64 with O_CREAT in third argument needs 4 arguments")))
                                                                  ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
openat64 (int __fd, __const char *__path, int __oflag, ...)
{
  if (__builtin_va_arg_pack_len () > 1)
    __openat64_too_many_args ();

  if (__builtin_constant_p (__oflag))
    {
      if ((__oflag & 0100) != 0 && __builtin_va_arg_pack_len () < 1)
 {
   __openat64_missing_mode ();
   return __openat64_2 (__fd, __path, __oflag);
 }
      return __openat64_alias (__fd, __path, __oflag, __builtin_va_arg_pack ());
    }

  if (__builtin_va_arg_pack_len () < 1)
    return __openat64_2 (__fd, __path, __oflag);

  return __openat64_alias (__fd, __path, __oflag, __builtin_va_arg_pack ());
}
# 253 "/usr/include/fcntl.h" 2 3 4



# 35 "../../qemu-common.h" 2
# 1 "/usr/include/sys/stat.h" 1 3 4
# 105 "/usr/include/sys/stat.h" 3 4


# 1 "/usr/include/bits/stat.h" 1 3 4
# 108 "/usr/include/sys/stat.h" 2 3 4
# 219 "/usr/include/sys/stat.h" 3 4
extern int stat (__const char *__restrict __file, struct stat *__restrict __buf) __asm__ ("" "stat64") __attribute__ ((__nothrow__))

     __attribute__ ((__nonnull__ (1, 2)));
extern int fstat (int __fd, struct stat *__buf) __asm__ ("" "fstat64") __attribute__ ((__nothrow__))
     __attribute__ ((__nonnull__ (2)));






extern int stat64 (__const char *__restrict __file,
     struct stat64 *__restrict __buf) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
extern int fstat64 (int __fd, struct stat64 *__buf) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
# 245 "/usr/include/sys/stat.h" 3 4
extern int fstatat (int __fd, __const char *__restrict __file, struct stat *__restrict __buf, int __flag) __asm__ ("" "fstatat64") __attribute__ ((__nothrow__))


                 __attribute__ ((__nonnull__ (2, 3)));






extern int fstatat64 (int __fd, __const char *__restrict __file,
        struct stat64 *__restrict __buf, int __flag)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));
# 269 "/usr/include/sys/stat.h" 3 4
extern int lstat (__const char *__restrict __file, struct stat *__restrict __buf) __asm__ ("" "lstat64") __attribute__ ((__nothrow__))


     __attribute__ ((__nonnull__ (1, 2)));





extern int lstat64 (__const char *__restrict __file,
      struct stat64 *__restrict __buf)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));





extern int chmod (__const char *__file, __mode_t __mode)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));





extern int lchmod (__const char *__file, __mode_t __mode)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));




extern int fchmod (int __fd, __mode_t __mode) __attribute__ ((__nothrow__));





extern int fchmodat (int __fd, __const char *__file, __mode_t __mode,
       int __flag)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));






extern __mode_t umask (__mode_t __mask) __attribute__ ((__nothrow__));




extern __mode_t getumask (void) __attribute__ ((__nothrow__));



extern int mkdir (__const char *__path, __mode_t __mode)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));





extern int mkdirat (int __fd, __const char *__path, __mode_t __mode)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));






extern int mknod (__const char *__path, __mode_t __mode, __dev_t __dev)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));





extern int mknodat (int __fd, __const char *__path, __mode_t __mode,
      __dev_t __dev) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));





extern int mkfifo (__const char *__path, __mode_t __mode)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));





extern int mkfifoat (int __fd, __const char *__path, __mode_t __mode)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));





extern int utimensat (int __fd, __const char *__path,
        __const struct timespec __times[2],
        int __flags)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));




extern int futimens (int __fd, __const struct timespec __times[2]) __attribute__ ((__nothrow__));
# 412 "/usr/include/sys/stat.h" 3 4
extern int __fxstat (int __ver, int __fildes, struct stat *__stat_buf) __asm__ ("" "__fxstat64") __attribute__ ((__nothrow__))

     __attribute__ ((__nonnull__ (3)));
extern int __xstat (int __ver, __const char *__filename, struct stat *__stat_buf) __asm__ ("" "__xstat64") __attribute__ ((__nothrow__))

     __attribute__ ((__nonnull__ (2, 3)));
extern int __lxstat (int __ver, __const char *__filename, struct stat *__stat_buf) __asm__ ("" "__lxstat64") __attribute__ ((__nothrow__))

     __attribute__ ((__nonnull__ (2, 3)));
extern int __fxstatat (int __ver, int __fildes, __const char *__filename, struct stat *__stat_buf, int __flag) __asm__ ("" "__fxstatat64") __attribute__ ((__nothrow__))


                    __attribute__ ((__nonnull__ (3, 4)));
# 434 "/usr/include/sys/stat.h" 3 4
extern int __fxstat64 (int __ver, int __fildes, struct stat64 *__stat_buf)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3)));
extern int __xstat64 (int __ver, __const char *__filename,
        struct stat64 *__stat_buf) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));
extern int __lxstat64 (int __ver, __const char *__filename,
         struct stat64 *__stat_buf) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));
extern int __fxstatat64 (int __ver, int __fildes, __const char *__filename,
    struct stat64 *__stat_buf, int __flag)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4)));

extern int __xmknod (int __ver, __const char *__path, __mode_t __mode,
       __dev_t *__dev) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 4)));

extern int __xmknodat (int __ver, int __fd, __const char *__path,
         __mode_t __mode, __dev_t *__dev)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 5)));




extern __inline int
__attribute__ ((__nothrow__)) stat (__const char *__path, struct stat *__statbuf)
{
  return __xstat (3, __path, __statbuf);
}


extern __inline int
__attribute__ ((__nothrow__)) lstat (__const char *__path, struct stat *__statbuf)
{
  return __lxstat (3, __path, __statbuf);
}


extern __inline int
__attribute__ ((__nothrow__)) fstat (int __fd, struct stat *__statbuf)
{
  return __fxstat (3, __fd, __statbuf);
}


extern __inline int
__attribute__ ((__nothrow__)) fstatat (int __fd, __const char *__filename, struct stat *__statbuf, int __flag)

{
  return __fxstatat (3, __fd, __filename, __statbuf, __flag);
}



extern __inline int
__attribute__ ((__nothrow__)) mknod (__const char *__path, __mode_t __mode, __dev_t __dev)
{
  return __xmknod (1, __path, __mode, &__dev);
}



extern __inline int
__attribute__ ((__nothrow__)) mknodat (int __fd, __const char *__path, __mode_t __mode, __dev_t __dev)

{
  return __xmknodat (1, __fd, __path, __mode, &__dev);
}





extern __inline int
__attribute__ ((__nothrow__)) stat64 (__const char *__path, struct stat64 *__statbuf)
{
  return __xstat64 (3, __path, __statbuf);
}


extern __inline int
__attribute__ ((__nothrow__)) lstat64 (__const char *__path, struct stat64 *__statbuf)
{
  return __lxstat64 (3, __path, __statbuf);
}


extern __inline int
__attribute__ ((__nothrow__)) fstat64 (int __fd, struct stat64 *__statbuf)
{
  return __fxstat64 (3, __fd, __statbuf);
}


extern __inline int
__attribute__ ((__nothrow__)) fstatat64 (int __fd, __const char *__filename, struct stat64 *__statbuf, int __flag)

{
  return __fxstatat64 (3, __fd, __filename, __statbuf, __flag);
}







# 36 "../../qemu-common.h" 2
# 1 "/usr/include/assert.h" 1 3 4
# 68 "/usr/include/assert.h" 3 4



extern void __assert_fail (__const char *__assertion, __const char *__file,
      unsigned int __line, __const char *__function)
     __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, __const char *__file,
      unsigned int __line,
      __const char *__function)
     __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));




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



# 37 "../../qemu-common.h" 2
# 68 "../../qemu-common.h"
# 1 "/usr/include/sys/uio.h" 1 3 4
# 26 "/usr/include/sys/uio.h" 3 4



# 1 "/usr/include/bits/uio.h" 1 3 4
# 30 "/usr/include/sys/uio.h" 2 3 4
# 40 "/usr/include/sys/uio.h" 3 4
extern ssize_t readv (int __fd, __const struct iovec *__iovec, int __count)
  __attribute__ ((__warn_unused_result__));
# 51 "/usr/include/sys/uio.h" 3 4
extern ssize_t writev (int __fd, __const struct iovec *__iovec, int __count)
  __attribute__ ((__warn_unused_result__));
# 82 "/usr/include/sys/uio.h" 3 4
extern ssize_t preadv (int __fd, __const struct iovec *__iovec, int __count, __off64_t __offset) __asm__ ("" "preadv64")

                __attribute__ ((__warn_unused_result__));
extern ssize_t pwritev (int __fd, __const struct iovec *__iovec, int __count, __off64_t __offset) __asm__ ("" "pwritev64")

                 __attribute__ ((__warn_unused_result__));
# 104 "/usr/include/sys/uio.h" 3 4
extern ssize_t preadv64 (int __fd, __const struct iovec *__iovec, int __count,
    __off64_t __offset) __attribute__ ((__warn_unused_result__));
# 116 "/usr/include/sys/uio.h" 3 4
extern ssize_t pwritev64 (int __fd, __const struct iovec *__iovec, int __count,
     __off64_t __offset) __attribute__ ((__warn_unused_result__));




# 69 "../../qemu-common.h" 2
# 87 "../../qemu-common.h"
typedef int (*fprintf_function)(FILE *f, const char *fmt, ...)
    __attribute__((format(gnu_printf, 2, 3)));
# 117 "../../qemu-common.h"
# 1 "../..//target-i386/cpu.h" 1
# 118 "../../qemu-common.h" 2




typedef void QEMUBHFunc(void *opaque);

void async_context_push(void);
void async_context_pop(void);
int get_async_context_id(void);

QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque);
void qemu_bh_schedule(QEMUBH *bh);






void qemu_bh_schedule_idle(QEMUBH *bh);
void qemu_bh_cancel(QEMUBH *bh);
void qemu_bh_delete(QEMUBH *bh);
int qemu_bh_poll(void);
void qemu_bh_update_timeout(int *timeout);

void qemu_get_timedate(struct tm *tm, int offset);
int qemu_timedate_diff(struct tm *tm);


void pstrcpy(char *buf, int buf_size, const char *str);
char *pstrcat(char *buf, int buf_size, const char *s);
int strstart(const char *str, const char *val, const char **ptr);
int stristart(const char *str, const char *val, const char **ptr);
int qemu_strnlen(const char *s, int max_len);
time_t mktimegm(struct tm *tm);
int qemu_fls(int i);
int qemu_fdatasync(int fd);
int fcntl_setfl(int fd, int flag);






int64_t strtosz(const char *nptr, char **end);
int64_t strtosz_suffix(const char *nptr, char **end, const char default_suffix);


void init_paths(const char *prefix);
const char *path(const char *pathname);
# 189 "../../qemu-common.h"
void *qemu_oom_check(void *ptr);
void *qemu_malloc(size_t size);
void *qemu_realloc(void *ptr, size_t size);
void *qemu_mallocz(size_t size);
void qemu_free(void *ptr);
char *qemu_strdup(const char *str);
char *qemu_strndup(const char *str, size_t size);

void qemu_mutex_lock_iothread(void);
void qemu_mutex_unlock_iothread(void);

int qemu_open(const char *name, int flags, ...);
ssize_t qemu_write_full(int fd, const void *buf, size_t count)
    __attribute__((warn_unused_result));
void qemu_set_cloexec(int fd);


int qemu_eventfd(int pipefd[2]);
int qemu_pipe(int pipefd[2]);




void __attribute__ ((__noreturn__)) hw_error(const char *fmt, ...) __attribute__((format(gnu_printf, 1, 2)));


typedef void IOReadHandler(void *opaque, const uint8_t *buf, int size);
typedef int IOCanReadHandler(void *opaque);
typedef void IOHandler(void *opaque);

struct ParallelIOArg {
    void *buffer;
    int count;
};

typedef int (*DMA_transfer_handler) (void *opaque, int nchan, int pos, int size);



typedef struct NICInfo NICInfo;
typedef struct HCIInfo HCIInfo;
typedef struct AudioState AudioState;
typedef struct BlockDriverState BlockDriverState;
typedef struct DriveInfo DriveInfo;
typedef struct DisplayState DisplayState;
typedef struct DisplayChangeListener DisplayChangeListener;
typedef struct DisplaySurface DisplaySurface;
typedef struct DisplayAllocator DisplayAllocator;
typedef struct PixelFormat PixelFormat;
typedef struct TextConsole TextConsole;
typedef TextConsole QEMUConsole;
typedef struct CharDriverState CharDriverState;
typedef struct MACAddr MACAddr;
typedef struct VLANState VLANState;
typedef struct VLANClientState VLANClientState;
typedef struct i2c_bus i2c_bus;
typedef struct i2c_slave i2c_slave;
typedef struct SMBusDevice SMBusDevice;
typedef struct PCIHostState PCIHostState;
typedef struct PCIExpressHost PCIExpressHost;
typedef struct PCIBus PCIBus;
typedef struct PCIDevice PCIDevice;
typedef struct PCIExpressDevice PCIExpressDevice;
typedef struct PCIBridge PCIBridge;
typedef struct PCIEAERMsg PCIEAERMsg;
typedef struct PCIEAERLog PCIEAERLog;
typedef struct PCIEAERErr PCIEAERErr;
typedef struct PCIEPort PCIEPort;
typedef struct PCIESlot PCIESlot;
typedef struct SerialState SerialState;
typedef struct IRQState *qemu_irq;
typedef struct PCMCIACardState PCMCIACardState;
typedef struct MouseTransformInfo MouseTransformInfo;
typedef struct uWireSlave uWireSlave;
typedef struct I2SCodec I2SCodec;
typedef struct SSIBus SSIBus;
typedef struct EventNotifier EventNotifier;
typedef struct VirtIODevice VirtIODevice;

typedef uint64_t pcibus_t;

typedef enum {
    IF_NONE,
    IF_IDE, IF_SCSI, IF_FLOPPY, IF_PFLASH, IF_MTD, IF_SD, IF_VIRTIO, IF_XEN,
    IF_COUNT
} BlockInterfaceType;

void cpu_exec_init_all(unsigned long tb_size);


void cpu_save(QEMUFile *f, void *opaque);
int cpu_load(QEMUFile *f, void *opaque, int version_id);


void qemu_service_io(void);


void qemu_notify_event(void);


void qemu_cpu_kick(void *env);
int qemu_cpu_self(void *env);


struct qemu_work_item {
    struct qemu_work_item *next;
    void (*func)(void *data);
    void *data;
    int done;
};




void qemu_init_vcpu(void *env);


typedef struct QEMUIOVector {
    struct iovec *iov;
    int niov;
    int nalloc;
    size_t size;
} QEMUIOVector;

void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint);
void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov);
void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len);
void qemu_iovec_copy(QEMUIOVector *dst, QEMUIOVector *src, uint64_t skip,
    size_t size);
void qemu_iovec_concat(QEMUIOVector *dst, QEMUIOVector *src, size_t size);
void qemu_iovec_destroy(QEMUIOVector *qiov);
void qemu_iovec_reset(QEMUIOVector *qiov);
void qemu_iovec_to_buffer(QEMUIOVector *qiov, void *buf);
void qemu_iovec_from_buffer(QEMUIOVector *qiov, const void *buf, size_t count);
void qemu_iovec_memset(QEMUIOVector *qiov, int c, size_t count);

struct Monitor;
typedef struct Monitor Monitor;


static inline uint8_t to_bcd(uint8_t val)
{
    return ((val / 10) << 4) | (val % 10);
}

static inline uint8_t from_bcd(uint8_t val)
{
    return ((val >> 4) * 10) + (val & 0x0f);
}


static inline uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
{
    union {
        uint64_t ll;
        struct {



            uint32_t low, high;

        } l;
    } u, res;
    uint64_t rl, rh;

    u.ll = a;
    rl = (uint64_t)u.l.low * (uint64_t)b;
    rh = (uint64_t)u.l.high * (uint64_t)b;
    rh += (rl >> 32);
    res.l.high = rh / c;
    res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
    return res.ll;
}

# 1 "../../module.h" 1
# 23 "../../module.h"
typedef enum {
    MODULE_INIT_BLOCK,
    MODULE_INIT_DEVICE,
    MODULE_INIT_MACHINE,
    MODULE_INIT_MAX
} module_init_type;





void register_module_init(void (*fn)(void), module_init_type type);

void module_call_init(module_init_type type);
# 364 "../../qemu-common.h" 2
# 24 "../../target-i386/cpu.h" 2
# 47 "../../target-i386/cpu.h"
# 1 "../../cpu-defs.h" 1
# 26 "../../cpu-defs.h"
# 1 "../../config.h" 1
# 1 "../config-host.h" 1
# 2 "../../config.h" 2
# 1 "./config-target.h" 1
# 2 "../../config.h" 2
# 27 "../../cpu-defs.h" 2
# 1 "/usr/include/setjmp.h" 1 3 4
# 28 "/usr/include/setjmp.h" 3 4


# 1 "/usr/include/bits/setjmp.h" 1 3 4
# 35 "/usr/include/bits/setjmp.h" 3 4
typedef int __jmp_buf[64] __attribute__((__aligned__ (8)));
# 31 "/usr/include/setjmp.h" 2 3 4
# 1 "/usr/include/bits/sigset.h" 1 3 4
# 32 "/usr/include/setjmp.h" 2 3 4



struct __jmp_buf_tag
  {




    __jmp_buf __jmpbuf;
    int __mask_was_saved;
    __sigset_t __saved_mask;
  };




typedef struct __jmp_buf_tag jmp_buf[1];



extern int setjmp (jmp_buf __env) __attribute__ ((__nothrow__));






extern int __sigsetjmp (struct __jmp_buf_tag __env[1], int __savemask) __attribute__ ((__nothrow__));




extern int _setjmp (struct __jmp_buf_tag __env[1]) __attribute__ ((__nothrow__));
# 78 "/usr/include/setjmp.h" 3 4




extern void longjmp (struct __jmp_buf_tag __env[1], int __val)
     __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));







extern void _longjmp (struct __jmp_buf_tag __env[1], int __val)
     __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));







typedef struct __jmp_buf_tag sigjmp_buf[1];
# 110 "/usr/include/setjmp.h" 3 4
extern void siglongjmp (sigjmp_buf __env, int __val)
     __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));





# 1 "/usr/include/bits/setjmp2.h" 1 3 4
# 26 "/usr/include/bits/setjmp2.h" 3 4
extern void longjmp (struct __jmp_buf_tag __env[1], int __val) __asm__ ("" "__longjmp_chk") __attribute__ ((__nothrow__))

                      __attribute__ ((__noreturn__));
extern void _longjmp (struct __jmp_buf_tag __env[1], int __val) __asm__ ("" "__longjmp_chk") __attribute__ ((__nothrow__))

                      __attribute__ ((__noreturn__));
extern void siglongjmp (struct __jmp_buf_tag __env[1], int __val) __asm__ ("" "__longjmp_chk") __attribute__ ((__nothrow__))

                      __attribute__ ((__noreturn__));
# 118 "/usr/include/setjmp.h" 2 3 4



# 28 "../../cpu-defs.h" 2


# 1 "../../osdep.h" 1




# 1 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include/stddef.h" 1 3 4
# 149 "/usr/lib/gcc/arm-linux-gnueabi/4.5.2/include/stddef.h" 3 4
typedef int ptrdiff_t;
# 6 "../../osdep.h" 2
# 89 "../../osdep.h"
void *qemu_memalign(size_t alignment, size_t size);
void *qemu_vmalloc(size_t size);
void qemu_vfree(void *ptr);
# 126 "../../osdep.h"
int qemu_madvise(void *addr, size_t len, int advice);

int qemu_create_pidfile(const char *filename);
# 31 "../../cpu-defs.h" 2
# 1 "../../qemu-queue.h" 1
# 32 "../../cpu-defs.h" 2
# 1 "../../targphys.h" 1
# 15 "../../targphys.h"
typedef uint64_t target_phys_addr_t;
# 33 "../../cpu-defs.h" 2
# 48 "../../cpu-defs.h"
typedef int64_t target_long;
typedef uint64_t target_ulong;
# 85 "../../cpu-defs.h"
typedef struct CPUTLBEntry {






    target_ulong addr_read;
    target_ulong addr_write;
    target_ulong addr_code;


    unsigned long addend;

    uint8_t dummy[(1 << 5) -
                  (sizeof(target_ulong) * 3 +
                   ((-sizeof(target_ulong) * 3) & (sizeof(unsigned long) - 1)) +
                   sizeof(unsigned long))];
} CPUTLBEntry;

extern int CPUTLBEntry_wrong_size[sizeof(CPUTLBEntry) == (1 << 5) ? 1 : -1];
# 127 "../../cpu-defs.h"
typedef struct icount_decr_u16 {
    uint16_t low;
    uint16_t high;
} icount_decr_u16;


struct kvm_run;
struct KVMState;
struct qemu_work_item;

typedef struct CPUBreakpoint {
    target_ulong pc;
    int flags;
    struct { struct CPUBreakpoint *tqe_next; struct CPUBreakpoint * *tqe_prev; } entry;
} CPUBreakpoint;

typedef struct CPUWatchpoint {
    target_ulong vaddr;
    target_ulong len_mask;
    int flags;
    struct { struct CPUWatchpoint *tqe_next; struct CPUWatchpoint * *tqe_prev; } entry;
} CPUWatchpoint;
# 48 "../../target-i386/cpu.h" 2

# 1 "../../fpu/softfloat.h" 1
# 40 "../../fpu/softfloat.h"
# 1 "../../config.h" 1
# 1 "../config-host.h" 1
# 2 "../../config.h" 2
# 1 "./config-target.h" 1
# 2 "../../config.h" 2
# 41 "../../fpu/softfloat.h" 2
# 50 "../../fpu/softfloat.h"
typedef uint8_t flag;
typedef uint8_t uint8;
typedef int8_t int8;

typedef int uint16;
typedef int int16;

typedef unsigned int uint32;
typedef signed int int32;
typedef uint64_t uint64;
typedef int64_t int64;







typedef uint8_t bits8;
typedef int8_t sbits8;
typedef uint16_t bits16;
typedef int16_t sbits16;
typedef uint32_t bits32;
typedef int32_t sbits32;
typedef uint64_t bits64;
typedef int64_t sbits64;
# 105 "../../fpu/softfloat.h"
enum {
    float_relation_less = -1,
    float_relation_equal = 0,
    float_relation_greater = 1,
    float_relation_unordered = 2
};
# 579 "../../fpu/softfloat.h"
# 1 "../../fpu/softfloat-native.h" 1

# 1 "/usr/include/math.h" 1 3 4
# 30 "/usr/include/math.h" 3 4




# 1 "/usr/include/bits/huge_val.h" 1 3 4
# 35 "/usr/include/math.h" 2 3 4

# 1 "/usr/include/bits/huge_valf.h" 1 3 4
# 37 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/bits/huge_vall.h" 1 3 4
# 38 "/usr/include/math.h" 2 3 4


# 1 "/usr/include/bits/inf.h" 1 3 4
# 41 "/usr/include/math.h" 2 3 4


# 1 "/usr/include/bits/nan.h" 1 3 4
# 44 "/usr/include/math.h" 2 3 4



# 1 "/usr/include/bits/mathdef.h" 1 3 4
# 28 "/usr/include/bits/mathdef.h" 3 4
typedef float float_t;

typedef double double_t;
# 48 "/usr/include/math.h" 2 3 4
# 71 "/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) __attribute__ ((__nothrow__)); extern double __acos (double __x) __attribute__ ((__nothrow__));

extern double asin (double __x) __attribute__ ((__nothrow__)); extern double __asin (double __x) __attribute__ ((__nothrow__));

extern double atan (double __x) __attribute__ ((__nothrow__)); extern double __atan (double __x) __attribute__ ((__nothrow__));

extern double atan2 (double __y, double __x) __attribute__ ((__nothrow__)); extern double __atan2 (double __y, double __x) __attribute__ ((__nothrow__));


extern double cos (double __x) __attribute__ ((__nothrow__)); extern double __cos (double __x) __attribute__ ((__nothrow__));

extern double sin (double __x) __attribute__ ((__nothrow__)); extern double __sin (double __x) __attribute__ ((__nothrow__));

extern double tan (double __x) __attribute__ ((__nothrow__)); extern double __tan (double __x) __attribute__ ((__nothrow__));




extern double cosh (double __x) __attribute__ ((__nothrow__)); extern double __cosh (double __x) __attribute__ ((__nothrow__));

extern double sinh (double __x) __attribute__ ((__nothrow__)); extern double __sinh (double __x) __attribute__ ((__nothrow__));

extern double tanh (double __x) __attribute__ ((__nothrow__)); extern double __tanh (double __x) __attribute__ ((__nothrow__));




extern void sincos (double __x, double *__sinx, double *__cosx) __attribute__ ((__nothrow__)); extern void __sincos (double __x, double *__sinx, double *__cosx) __attribute__ ((__nothrow__))
                                                           ;





extern double acosh (double __x) __attribute__ ((__nothrow__)); extern double __acosh (double __x) __attribute__ ((__nothrow__));

extern double asinh (double __x) __attribute__ ((__nothrow__)); extern double __asinh (double __x) __attribute__ ((__nothrow__));

extern double atanh (double __x) __attribute__ ((__nothrow__)); extern double __atanh (double __x) __attribute__ ((__nothrow__));







extern double exp (double __x) __attribute__ ((__nothrow__)); extern double __exp (double __x) __attribute__ ((__nothrow__));


extern double frexp (double __x, int *__exponent) __attribute__ ((__nothrow__)); extern double __frexp (double __x, int *__exponent) __attribute__ ((__nothrow__));


extern double ldexp (double __x, int __exponent) __attribute__ ((__nothrow__)); extern double __ldexp (double __x, int __exponent) __attribute__ ((__nothrow__));


extern double log (double __x) __attribute__ ((__nothrow__)); extern double __log (double __x) __attribute__ ((__nothrow__));


extern double log10 (double __x) __attribute__ ((__nothrow__)); extern double __log10 (double __x) __attribute__ ((__nothrow__));


extern double modf (double __x, double *__iptr) __attribute__ ((__nothrow__)); extern double __modf (double __x, double *__iptr) __attribute__ ((__nothrow__));




extern double exp10 (double __x) __attribute__ ((__nothrow__)); extern double __exp10 (double __x) __attribute__ ((__nothrow__));

extern double pow10 (double __x) __attribute__ ((__nothrow__)); extern double __pow10 (double __x) __attribute__ ((__nothrow__));





extern double expm1 (double __x) __attribute__ ((__nothrow__)); extern double __expm1 (double __x) __attribute__ ((__nothrow__));


extern double log1p (double __x) __attribute__ ((__nothrow__)); extern double __log1p (double __x) __attribute__ ((__nothrow__));


extern double logb (double __x) __attribute__ ((__nothrow__)); extern double __logb (double __x) __attribute__ ((__nothrow__));






extern double exp2 (double __x) __attribute__ ((__nothrow__)); extern double __exp2 (double __x) __attribute__ ((__nothrow__));


extern double log2 (double __x) __attribute__ ((__nothrow__)); extern double __log2 (double __x) __attribute__ ((__nothrow__));








extern double pow (double __x, double __y) __attribute__ ((__nothrow__)); extern double __pow (double __x, double __y) __attribute__ ((__nothrow__));


extern double sqrt (double __x) __attribute__ ((__nothrow__)); extern double __sqrt (double __x) __attribute__ ((__nothrow__));





extern double hypot (double __x, double __y) __attribute__ ((__nothrow__)); extern double __hypot (double __x, double __y) __attribute__ ((__nothrow__));






extern double cbrt (double __x) __attribute__ ((__nothrow__)); extern double __cbrt (double __x) __attribute__ ((__nothrow__));








extern double ceil (double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern double __ceil (double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern double fabs (double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern double __fabs (double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern double floor (double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern double __floor (double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern double fmod (double __x, double __y) __attribute__ ((__nothrow__)); extern double __fmod (double __x, double __y) __attribute__ ((__nothrow__));




extern int __isinf (double __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern int __finite (double __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));





extern int isinf (double __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern int finite (double __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern double drem (double __x, double __y) __attribute__ ((__nothrow__)); extern double __drem (double __x, double __y) __attribute__ ((__nothrow__));



extern double significand (double __x) __attribute__ ((__nothrow__)); extern double __significand (double __x) __attribute__ ((__nothrow__));





extern double copysign (double __x, double __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern double __copysign (double __x, double __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__));






extern double nan (__const char *__tagb) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern double __nan (__const char *__tagb) __attribute__ ((__nothrow__)) __attribute__ ((__const__));





extern int __isnan (double __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));



extern int isnan (double __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern double j0 (double) __attribute__ ((__nothrow__)); extern double __j0 (double) __attribute__ ((__nothrow__));
extern double j1 (double) __attribute__ ((__nothrow__)); extern double __j1 (double) __attribute__ ((__nothrow__));
extern double jn (int, double) __attribute__ ((__nothrow__)); extern double __jn (int, double) __attribute__ ((__nothrow__));
extern double y0 (double) __attribute__ ((__nothrow__)); extern double __y0 (double) __attribute__ ((__nothrow__));
extern double y1 (double) __attribute__ ((__nothrow__)); extern double __y1 (double) __attribute__ ((__nothrow__));
extern double yn (int, double) __attribute__ ((__nothrow__)); extern double __yn (int, double) __attribute__ ((__nothrow__));






extern double erf (double) __attribute__ ((__nothrow__)); extern double __erf (double) __attribute__ ((__nothrow__));
extern double erfc (double) __attribute__ ((__nothrow__)); extern double __erfc (double) __attribute__ ((__nothrow__));
extern double lgamma (double) __attribute__ ((__nothrow__)); extern double __lgamma (double) __attribute__ ((__nothrow__));






extern double tgamma (double) __attribute__ ((__nothrow__)); extern double __tgamma (double) __attribute__ ((__nothrow__));





extern double gamma (double) __attribute__ ((__nothrow__)); extern double __gamma (double) __attribute__ ((__nothrow__));






extern double lgamma_r (double, int *__signgamp) __attribute__ ((__nothrow__)); extern double __lgamma_r (double, int *__signgamp) __attribute__ ((__nothrow__));







extern double rint (double __x) __attribute__ ((__nothrow__)); extern double __rint (double __x) __attribute__ ((__nothrow__));


extern double nextafter (double __x, double __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__));

extern double nexttoward (double __x, long double __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__));



extern double remainder (double __x, double __y) __attribute__ ((__nothrow__)); extern double __remainder (double __x, double __y) __attribute__ ((__nothrow__));



extern double scalbn (double __x, int __n) __attribute__ ((__nothrow__)); extern double __scalbn (double __x, int __n) __attribute__ ((__nothrow__));



extern int ilogb (double __x) __attribute__ ((__nothrow__)); extern int __ilogb (double __x) __attribute__ ((__nothrow__));




extern double scalbln (double __x, long int __n) __attribute__ ((__nothrow__)); extern double __scalbln (double __x, long int __n) __attribute__ ((__nothrow__));



extern double nearbyint (double __x) __attribute__ ((__nothrow__)); extern double __nearbyint (double __x) __attribute__ ((__nothrow__));



extern double round (double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern double __round (double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));



extern double trunc (double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern double __trunc (double __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));




extern double remquo (double __x, double __y, int *__quo) __attribute__ ((__nothrow__)); extern double __remquo (double __x, double __y, int *__quo) __attribute__ ((__nothrow__));






extern long int lrint (double __x) __attribute__ ((__nothrow__)); extern long int __lrint (double __x) __attribute__ ((__nothrow__));
extern long long int llrint (double __x) __attribute__ ((__nothrow__)); extern long long int __llrint (double __x) __attribute__ ((__nothrow__));



extern long int lround (double __x) __attribute__ ((__nothrow__)); extern long int __lround (double __x) __attribute__ ((__nothrow__));
extern long long int llround (double __x) __attribute__ ((__nothrow__)); extern long long int __llround (double __x) __attribute__ ((__nothrow__));



extern double fdim (double __x, double __y) __attribute__ ((__nothrow__)); extern double __fdim (double __x, double __y) __attribute__ ((__nothrow__));


extern double fmax (double __x, double __y) __attribute__ ((__nothrow__)); extern double __fmax (double __x, double __y) __attribute__ ((__nothrow__));


extern double fmin (double __x, double __y) __attribute__ ((__nothrow__)); extern double __fmin (double __x, double __y) __attribute__ ((__nothrow__));



extern int __fpclassify (double __value) __attribute__ ((__nothrow__))
     __attribute__ ((__const__));


extern int __signbit (double __value) __attribute__ ((__nothrow__))
     __attribute__ ((__const__));



extern double fma (double __x, double __y, double __z) __attribute__ ((__nothrow__)); extern double __fma (double __x, double __y, double __z) __attribute__ ((__nothrow__));








extern double scalb (double __x, double __n) __attribute__ ((__nothrow__)); extern double __scalb (double __x, double __n) __attribute__ ((__nothrow__));
# 72 "/usr/include/math.h" 2 3 4
# 94 "/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) __attribute__ ((__nothrow__)); extern float __acosf (float __x) __attribute__ ((__nothrow__));

extern float asinf (float __x) __attribute__ ((__nothrow__)); extern float __asinf (float __x) __attribute__ ((__nothrow__));

extern float atanf (float __x) __attribute__ ((__nothrow__)); extern float __atanf (float __x) __attribute__ ((__nothrow__));

extern float atan2f (float __y, float __x) __attribute__ ((__nothrow__)); extern float __atan2f (float __y, float __x) __attribute__ ((__nothrow__));


extern float cosf (float __x) __attribute__ ((__nothrow__)); extern float __cosf (float __x) __attribute__ ((__nothrow__));

extern float sinf (float __x) __attribute__ ((__nothrow__)); extern float __sinf (float __x) __attribute__ ((__nothrow__));

extern float tanf (float __x) __attribute__ ((__nothrow__)); extern float __tanf (float __x) __attribute__ ((__nothrow__));




extern float coshf (float __x) __attribute__ ((__nothrow__)); extern float __coshf (float __x) __attribute__ ((__nothrow__));

extern float sinhf (float __x) __attribute__ ((__nothrow__)); extern float __sinhf (float __x) __attribute__ ((__nothrow__));

extern float tanhf (float __x) __attribute__ ((__nothrow__)); extern float __tanhf (float __x) __attribute__ ((__nothrow__));




extern void
 sincosf
# 82 "/usr/include/bits/mathcalls.h" 3 4
 (float __x, float *__sinx, float *__cosx) __attribute__ ((__nothrow__)); extern void
 __sincosf
# 82 "/usr/include/bits/mathcalls.h" 3 4
 (float __x, float *__sinx, float *__cosx) __attribute__ ((__nothrow__))
                                                           ;





extern float acoshf (float __x) __attribute__ ((__nothrow__)); extern float __acoshf (float __x) __attribute__ ((__nothrow__));

extern float asinhf (float __x) __attribute__ ((__nothrow__)); extern float __asinhf (float __x) __attribute__ ((__nothrow__));

extern float atanhf (float __x) __attribute__ ((__nothrow__)); extern float __atanhf (float __x) __attribute__ ((__nothrow__));







extern float expf (float __x) __attribute__ ((__nothrow__)); extern float __expf (float __x) __attribute__ ((__nothrow__));


extern float frexpf (float __x, int *__exponent) __attribute__ ((__nothrow__)); extern float __frexpf (float __x, int *__exponent) __attribute__ ((__nothrow__));


extern float ldexpf (float __x, int __exponent) __attribute__ ((__nothrow__)); extern float __ldexpf (float __x, int __exponent) __attribute__ ((__nothrow__));


extern float logf (float __x) __attribute__ ((__nothrow__)); extern float __logf (float __x) __attribute__ ((__nothrow__));


extern float log10f (float __x) __attribute__ ((__nothrow__)); extern float __log10f (float __x) __attribute__ ((__nothrow__));


extern float modff (float __x, float *__iptr) __attribute__ ((__nothrow__)); extern float __modff (float __x, float *__iptr) __attribute__ ((__nothrow__));




extern float exp10f (float __x) __attribute__ ((__nothrow__)); extern float __exp10f (float __x) __attribute__ ((__nothrow__));

extern float pow10f (float __x) __attribute__ ((__nothrow__)); extern float __pow10f (float __x) __attribute__ ((__nothrow__));





extern float expm1f (float __x) __attribute__ ((__nothrow__)); extern float __expm1f (float __x) __attribute__ ((__nothrow__));


extern float log1pf (float __x) __attribute__ ((__nothrow__)); extern float __log1pf (float __x) __attribute__ ((__nothrow__));


extern float logbf (float __x) __attribute__ ((__nothrow__)); extern float __logbf (float __x) __attribute__ ((__nothrow__));






extern float exp2f (float __x) __attribute__ ((__nothrow__)); extern float __exp2f (float __x) __attribute__ ((__nothrow__));


extern float log2f (float __x) __attribute__ ((__nothrow__)); extern float __log2f (float __x) __attribute__ ((__nothrow__));








extern float powf (float __x, float __y) __attribute__ ((__nothrow__)); extern float __powf (float __x, float __y) __attribute__ ((__nothrow__));


extern float sqrtf (float __x) __attribute__ ((__nothrow__)); extern float __sqrtf (float __x) __attribute__ ((__nothrow__));





extern float hypotf (float __x, float __y) __attribute__ ((__nothrow__)); extern float __hypotf (float __x, float __y) __attribute__ ((__nothrow__));






extern float cbrtf (float __x) __attribute__ ((__nothrow__)); extern float __cbrtf (float __x) __attribute__ ((__nothrow__));








extern float ceilf (float __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern float __ceilf (float __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern float fabsf (float __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern float __fabsf (float __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern float floorf (float __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern float __floorf (float __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern float fmodf (float __x, float __y) __attribute__ ((__nothrow__)); extern float __fmodf (float __x, float __y) __attribute__ ((__nothrow__));




extern int __isinff (float __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern int __finitef (float __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));





extern int isinff (float __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern int finitef (float __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern float dremf (float __x, float __y) __attribute__ ((__nothrow__)); extern float __dremf (float __x, float __y) __attribute__ ((__nothrow__));



extern float significandf (float __x) __attribute__ ((__nothrow__)); extern float __significandf (float __x) __attribute__ ((__nothrow__));





extern float copysignf (float __x, float __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__));






extern float nanf (__const char *__tagb) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern float __nanf (__const char *__tagb) __attribute__ ((__nothrow__)) __attribute__ ((__const__));





extern int __isnanf (float __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));



extern int isnanf (float __value) __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern float j0f (float) __attribute__ ((__nothrow__)); extern float __j0f (float) __attribute__ ((__nothrow__));
extern float j1f (float) __attribute__ ((__nothrow__)); extern float __j1f (float) __attribute__ ((__nothrow__));
extern float jnf (int, float) __attribute__ ((__nothrow__)); extern float __jnf (int, float) __attribute__ ((__nothrow__));
extern float y0f (float) __attribute__ ((__nothrow__)); extern float __y0f (float) __attribute__ ((__nothrow__));
extern float y1f (float) __attribute__ ((__nothrow__)); extern float __y1f (float) __attribute__ ((__nothrow__));
extern float ynf (int, float) __attribute__ ((__nothrow__)); extern float __ynf (int, float) __attribute__ ((__nothrow__));






extern float erff (float) __attribute__ ((__nothrow__)); extern float __erff (float) __attribute__ ((__nothrow__));
extern float erfcf (float) __attribute__ ((__nothrow__)); extern float __erfcf (float) __attribute__ ((__nothrow__));
extern float lgammaf (float) __attribute__ ((__nothrow__)); extern float __lgammaf (float) __attribute__ ((__nothrow__));






extern float tgammaf (float) __attribute__ ((__nothrow__)); extern float __tgammaf (float) __attribute__ ((__nothrow__));





extern float gammaf (float) __attribute__ ((__nothrow__)); extern float __gammaf (float) __attribute__ ((__nothrow__));






extern float lgammaf_r (float, int *__signgamp) __attribute__ ((__nothrow__)); extern float __lgammaf_r (float, int *__signgamp) __attribute__ ((__nothrow__));







extern float rintf (float __x) __attribute__ ((__nothrow__)); extern float __rintf (float __x) __attribute__ ((__nothrow__));


extern float nextafterf (float __x, float __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__));

extern float nexttowardf (float __x, long double __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) __attribute__ ((__nothrow__)) __attribute__ ((__const__));



extern float remainderf (float __x, float __y) __attribute__ ((__nothrow__)); extern float __remainderf (float __x, float __y) __attribute__ ((__nothrow__));



extern float scalbnf (float __x, int __n) __attribute__ ((__nothrow__)); extern float __scalbnf (float __x, int __n) __attribute__ ((__nothrow__));



extern int ilogbf (float __x) __attribute__ ((__nothrow__)); extern int __ilogbf (float __x) __attribute__ ((__nothrow__));




extern float scalblnf (float __x, long int __n) __attribute__ ((__nothrow__)); extern float __scalblnf (float __x, long int __n) __attribute__ ((__nothrow__));



extern float nearbyintf (float __x) __attribute__ ((__nothrow__)); extern float __nearbyintf (float __x) __attribute__ ((__nothrow__));



extern float roundf (float __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern float __roundf (float __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));



extern float truncf (float __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern float __truncf (float __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));




extern float remquof (float __x, float __y, int *__quo) __attribute__ ((__nothrow__)); extern float __remquof (float __x, float __y, int *__quo) __attribute__ ((__nothrow__));






extern long int lrintf (float __x) __attribute__ ((__nothrow__)); extern long int __lrintf (float __x) __attribute__ ((__nothrow__));
extern long long int llrintf (float __x) __attribute__ ((__nothrow__)); extern long long int __llrintf (float __x) __attribute__ ((__nothrow__));



extern long int lroundf (float __x) __attribute__ ((__nothrow__)); extern long int __lroundf (float __x) __attribute__ ((__nothrow__));
extern long long int llroundf (float __x) __attribute__ ((__nothrow__)); extern long long int __llroundf (float __x) __attribute__ ((__nothrow__));



extern float fdimf (float __x, float __y) __attribute__ ((__nothrow__)); extern float __fdimf (float __x, float __y) __attribute__ ((__nothrow__));


extern float fmaxf (float __x, float __y) __attribute__ ((__nothrow__)); extern float __fmaxf (float __x, float __y) __attribute__ ((__nothrow__));


extern float fminf (float __x, float __y) __attribute__ ((__nothrow__)); extern float __fminf (float __x, float __y) __attribute__ ((__nothrow__));



extern int __fpclassifyf (float __value) __attribute__ ((__nothrow__))
     __attribute__ ((__const__));


extern int __signbitf (float __value) __attribute__ ((__nothrow__))
     __attribute__ ((__const__));



extern float fmaf (float __x, float __y, float __z) __attribute__ ((__nothrow__)); extern float __fmaf (float __x, float __y, float __z) __attribute__ ((__nothrow__));








extern float scalbf (float __x, float __n) __attribute__ ((__nothrow__)); extern float __scalbf (float __x, float __n) __attribute__ ((__nothrow__));
# 95 "/usr/include/math.h" 2 3 4
# 145 "/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) __asm__ ("" "acos") __attribute__ ((__nothrow__)); extern long double __acosl (long double __x) __asm__ ("" "__acos") __attribute__ ((__nothrow__));

extern long double asinl (long double __x) __asm__ ("" "asin") __attribute__ ((__nothrow__)); extern long double __asinl (long double __x) __asm__ ("" "__asin") __attribute__ ((__nothrow__));

extern long double atanl (long double __x) __asm__ ("" "atan") __attribute__ ((__nothrow__)); extern long double __atanl (long double __x) __asm__ ("" "__atan") __attribute__ ((__nothrow__));

extern long double atan2l (long double __y, long double __x) __asm__ ("" "atan2") __attribute__ ((__nothrow__)); extern long double __atan2l (long double __y, long double __x) __asm__ ("" "__atan2") __attribute__ ((__nothrow__));


extern long double cosl (long double __x) __asm__ ("" "cos") __attribute__ ((__nothrow__)); extern long double __cosl (long double __x) __asm__ ("" "__cos") __attribute__ ((__nothrow__));

extern long double sinl (long double __x) __asm__ ("" "sin") __attribute__ ((__nothrow__)); extern long double __sinl (long double __x) __asm__ ("" "__sin") __attribute__ ((__nothrow__));

extern long double tanl (long double __x) __asm__ ("" "tan") __attribute__ ((__nothrow__)); extern long double __tanl (long double __x) __asm__ ("" "__tan") __attribute__ ((__nothrow__));




extern long double coshl (long double __x) __asm__ ("" "cosh") __attribute__ ((__nothrow__)); extern long double __coshl (long double __x) __asm__ ("" "__cosh") __attribute__ ((__nothrow__));

extern long double sinhl (long double __x) __asm__ ("" "sinh") __attribute__ ((__nothrow__)); extern long double __sinhl (long double __x) __asm__ ("" "__sinh") __attribute__ ((__nothrow__));

extern long double tanhl (long double __x) __asm__ ("" "tanh") __attribute__ ((__nothrow__)); extern long double __tanhl (long double __x) __asm__ ("" "__tanh") __attribute__ ((__nothrow__));




extern void sincosl (long double __x, long double *__sinx, long double *__cosx) __asm__ ("" "sincos") __attribute__ ((__nothrow__)); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) __asm__ ("" "__sincos") __attribute__ ((__nothrow__))
                                                           ;





extern long double acoshl (long double __x) __asm__ ("" "acosh") __attribute__ ((__nothrow__)); extern long double __acoshl (long double __x) __asm__ ("" "__acosh") __attribute__ ((__nothrow__));

extern long double asinhl (long double __x) __asm__ ("" "asinh") __attribute__ ((__nothrow__)); extern long double __asinhl (long double __x) __asm__ ("" "__asinh") __attribute__ ((__nothrow__));

extern long double atanhl (long double __x) __asm__ ("" "atanh") __attribute__ ((__nothrow__)); extern long double __atanhl (long double __x) __asm__ ("" "__atanh") __attribute__ ((__nothrow__));







extern long double expl (long double __x) __asm__ ("" "exp") __attribute__ ((__nothrow__)); extern long double __expl (long double __x) __asm__ ("" "__exp") __attribute__ ((__nothrow__));


extern long double frexpl (long double __x, int *__exponent) __asm__ ("" "frexp") __attribute__ ((__nothrow__)); extern long double __frexpl (long double __x, int *__exponent) __asm__ ("" "__frexp") __attribute__ ((__nothrow__));


extern long double ldexpl (long double __x, int __exponent) __asm__ ("" "ldexp") __attribute__ ((__nothrow__)); extern long double __ldexpl (long double __x, int __exponent) __asm__ ("" "__ldexp") __attribute__ ((__nothrow__));


extern long double logl (long double __x) __asm__ ("" "log") __attribute__ ((__nothrow__)); extern long double __logl (long double __x) __asm__ ("" "__log") __attribute__ ((__nothrow__));


extern long double log10l (long double __x) __asm__ ("" "log10") __attribute__ ((__nothrow__)); extern long double __log10l (long double __x) __asm__ ("" "__log10") __attribute__ ((__nothrow__));


extern long double modfl (long double __x, long double *__iptr) __asm__ ("" "modf") __attribute__ ((__nothrow__)); extern long double __modfl (long double __x, long double *__iptr) __asm__ ("" "__modf") __attribute__ ((__nothrow__));




extern long double exp10l (long double __x) __asm__ ("" "exp10") __attribute__ ((__nothrow__)); extern long double __exp10l (long double __x) __asm__ ("" "__exp10") __attribute__ ((__nothrow__));

extern long double pow10l (long double __x) __asm__ ("" "pow10") __attribute__ ((__nothrow__)); extern long double __pow10l (long double __x) __asm__ ("" "__pow10") __attribute__ ((__nothrow__));





extern long double expm1l (long double __x) __asm__ ("" "expm1") __attribute__ ((__nothrow__)); extern long double __expm1l (long double __x) __asm__ ("" "__expm1") __attribute__ ((__nothrow__));


extern long double log1pl (long double __x) __asm__ ("" "log1p") __attribute__ ((__nothrow__)); extern long double __log1pl (long double __x) __asm__ ("" "__log1p") __attribute__ ((__nothrow__));


extern long double logbl (long double __x) __asm__ ("" "logb") __attribute__ ((__nothrow__)); extern long double __logbl (long double __x) __asm__ ("" "__logb") __attribute__ ((__nothrow__));






extern long double exp2l (long double __x) __asm__ ("" "exp2") __attribute__ ((__nothrow__)); extern long double __exp2l (long double __x) __asm__ ("" "__exp2") __attribute__ ((__nothrow__));


extern long double log2l (long double __x) __asm__ ("" "log2") __attribute__ ((__nothrow__)); extern long double __log2l (long double __x) __asm__ ("" "__log2") __attribute__ ((__nothrow__));








extern long double powl (long double __x, long double __y) __asm__ ("" "pow") __attribute__ ((__nothrow__)); extern long double __powl (long double __x, long double __y) __asm__ ("" "__pow") __attribute__ ((__nothrow__));


extern long double sqrtl (long double __x) __asm__ ("" "sqrt") __attribute__ ((__nothrow__)); extern long double __sqrtl (long double __x) __asm__ ("" "__sqrt") __attribute__ ((__nothrow__));





extern long double hypotl (long double __x, long double __y) __asm__ ("" "hypot") __attribute__ ((__nothrow__)); extern long double __hypotl (long double __x, long double __y) __asm__ ("" "__hypot") __attribute__ ((__nothrow__));






extern long double cbrtl (long double __x) __asm__ ("" "cbrt") __attribute__ ((__nothrow__)); extern long double __cbrtl (long double __x) __asm__ ("" "__cbrt") __attribute__ ((__nothrow__));








extern long double ceill (long double __x) __asm__ ("" "ceil") __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern long double __ceill (long double __x) __asm__ ("" "__ceil") __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern long double fabsl (long double __x) __asm__ ("" "fabs") __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern long double __fabsl (long double __x) __asm__ ("" "__fabs") __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern long double floorl (long double __x) __asm__ ("" "floor") __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern long double __floorl (long double __x) __asm__ ("" "__floor") __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern long double fmodl (long double __x, long double __y) __asm__ ("" "fmod") __attribute__ ((__nothrow__)); extern long double __fmodl (long double __x, long double __y) __asm__ ("" "__fmod") __attribute__ ((__nothrow__));




extern int __isinfl (long double __value) __asm__ ("" "__isinf") __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern int __finitel (long double __value) __asm__ ("" "__finite") __attribute__ ((__nothrow__)) __attribute__ ((__const__));





extern int isinfl (long double __value) __asm__ ("" "isinf") __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern int finitel (long double __value) __asm__ ("" "finite") __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern long double dreml (long double __x, long double __y) __asm__ ("" "drem") __attribute__ ((__nothrow__)); extern long double __dreml (long double __x, long double __y) __asm__ ("" "__drem") __attribute__ ((__nothrow__));



extern long double significandl (long double __x) __asm__ ("" "significand") __attribute__ ((__nothrow__)); extern long double __significandl (long double __x) __asm__ ("" "__significand") __attribute__ ((__nothrow__));





extern long double copysignl (long double __x, long double __y) __asm__ ("" "copysign") __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) __asm__ ("" "__copysign") __attribute__ ((__nothrow__)) __attribute__ ((__const__));






extern long double nanl (__const char *__tagb) __asm__ ("" "nan") __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern long double __nanl (__const char *__tagb) __asm__ ("" "__nan") __attribute__ ((__nothrow__)) __attribute__ ((__const__));





extern int __isnanl (long double __value) __asm__ ("" "__isnan") __attribute__ ((__nothrow__)) __attribute__ ((__const__));



extern int isnanl (long double __value) __asm__ ("" "isnan") __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern long double j0l (long double) __asm__ ("" "j0") __attribute__ ((__nothrow__)); extern long double __j0l (long double) __asm__ ("" "__j0") __attribute__ ((__nothrow__));
extern long double j1l (long double) __asm__ ("" "j1") __attribute__ ((__nothrow__)); extern long double __j1l (long double) __asm__ ("" "__j1") __attribute__ ((__nothrow__));
extern long double jnl (int, long double) __asm__ ("" "jn") __attribute__ ((__nothrow__)); extern long double __jnl (int, long double) __asm__ ("" "__jn") __attribute__ ((__nothrow__));
extern long double y0l (long double) __asm__ ("" "y0") __attribute__ ((__nothrow__)); extern long double __y0l (long double) __asm__ ("" "__y0") __attribute__ ((__nothrow__));
extern long double y1l (long double) __asm__ ("" "y1") __attribute__ ((__nothrow__)); extern long double __y1l (long double) __asm__ ("" "__y1") __attribute__ ((__nothrow__));
extern long double ynl (int, long double) __asm__ ("" "yn") __attribute__ ((__nothrow__)); extern long double __ynl (int, long double) __asm__ ("" "__yn") __attribute__ ((__nothrow__));






extern long double erfl (long double) __asm__ ("" "erf") __attribute__ ((__nothrow__)); extern long double __erfl (long double) __asm__ ("" "__erf") __attribute__ ((__nothrow__));
extern long double erfcl (long double) __asm__ ("" "erfc") __attribute__ ((__nothrow__)); extern long double __erfcl (long double) __asm__ ("" "__erfc") __attribute__ ((__nothrow__));
extern long double lgammal (long double) __asm__ ("" "lgamma") __attribute__ ((__nothrow__)); extern long double __lgammal (long double) __asm__ ("" "__lgamma") __attribute__ ((__nothrow__));






extern long double tgammal (long double) __asm__ ("" "tgamma") __attribute__ ((__nothrow__)); extern long double __tgammal (long double) __asm__ ("" "__tgamma") __attribute__ ((__nothrow__));





extern long double gammal (long double) __asm__ ("" "gamma") __attribute__ ((__nothrow__)); extern long double __gammal (long double) __asm__ ("" "__gamma") __attribute__ ((__nothrow__));






extern long double lgammal_r (long double, int *__signgamp) __asm__ ("" "lgamma_r") __attribute__ ((__nothrow__)); extern long double __lgammal_r (long double, int *__signgamp) __asm__ ("" "__lgamma_r") __attribute__ ((__nothrow__));







extern long double rintl (long double __x) __asm__ ("" "rint") __attribute__ ((__nothrow__)); extern long double __rintl (long double __x) __asm__ ("" "__rint") __attribute__ ((__nothrow__));


extern long double nextafterl (long double __x, long double __y) __asm__ ("" "nextafter") __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) __asm__ ("" "__nextafter") __attribute__ ((__nothrow__)) __attribute__ ((__const__));

extern long double nexttowardl (long double __x, long double __y) __asm__ ("" "nexttoward") __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) __asm__ ("" "__nexttoward") __attribute__ ((__nothrow__)) __attribute__ ((__const__));



extern long double remainderl (long double __x, long double __y) __asm__ ("" "remainder") __attribute__ ((__nothrow__)); extern long double __remainderl (long double __x, long double __y) __asm__ ("" "__remainder") __attribute__ ((__nothrow__));



extern long double scalbnl (long double __x, int __n) __asm__ ("" "scalbn") __attribute__ ((__nothrow__)); extern long double __scalbnl (long double __x, int __n) __asm__ ("" "__scalbn") __attribute__ ((__nothrow__));



extern int ilogbl (long double __x) __asm__ ("" "ilogb") __attribute__ ((__nothrow__)); extern int __ilogbl (long double __x) __asm__ ("" "__ilogb") __attribute__ ((__nothrow__));




extern long double scalblnl (long double __x, long int __n) __asm__ ("" "scalbln") __attribute__ ((__nothrow__)); extern long double __scalblnl (long double __x, long int __n) __asm__ ("" "__scalbln") __attribute__ ((__nothrow__));



extern long double nearbyintl (long double __x) __asm__ ("" "nearbyint") __attribute__ ((__nothrow__)); extern long double __nearbyintl (long double __x) __asm__ ("" "__nearbyint") __attribute__ ((__nothrow__));



extern long double roundl (long double __x) __asm__ ("" "round") __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern long double __roundl (long double __x) __asm__ ("" "__round") __attribute__ ((__nothrow__)) __attribute__ ((__const__));



extern long double truncl (long double __x) __asm__ ("" "trunc") __attribute__ ((__nothrow__)) __attribute__ ((__const__)); extern long double __truncl (long double __x) __asm__ ("" "__trunc") __attribute__ ((__nothrow__)) __attribute__ ((__const__));




extern long double remquol (long double __x, long double __y, int *__quo) __asm__ ("" "remquo") __attribute__ ((__nothrow__)); extern long double __remquol (long double __x, long double __y, int *__quo) __asm__ ("" "__remquo") __attribute__ ((__nothrow__));






extern long int lrintl (long double __x) __asm__ ("" "lrint") __attribute__ ((__nothrow__)); extern long int __lrintl (long double __x) __asm__ ("" "__lrint") __attribute__ ((__nothrow__));
extern long long int llrintl (long double __x) __asm__ ("" "llrint") __attribute__ ((__nothrow__)); extern long long int __llrintl (long double __x) __asm__ ("" "__llrint") __attribute__ ((__nothrow__));



extern long int lroundl (long double __x) __asm__ ("" "lround") __attribute__ ((__nothrow__)); extern long int __lroundl (long double __x) __asm__ ("" "__lround") __attribute__ ((__nothrow__));
extern long long int llroundl (long double __x) __asm__ ("" "llround") __attribute__ ((__nothrow__)); extern long long int __llroundl (long double __x) __asm__ ("" "__llround") __attribute__ ((__nothrow__));



extern long double fdiml (long double __x, long double __y) __asm__ ("" "fdim") __attribute__ ((__nothrow__)); extern long double __fdiml (long double __x, long double __y) __asm__ ("" "__fdim") __attribute__ ((__nothrow__));


extern long double fmaxl (long double __x, long double __y) __asm__ ("" "fmax") __attribute__ ((__nothrow__)); extern long double __fmaxl (long double __x, long double __y) __asm__ ("" "__fmax") __attribute__ ((__nothrow__));


extern long double fminl (long double __x, long double __y) __asm__ ("" "fmin") __attribute__ ((__nothrow__)); extern long double __fminl (long double __x, long double __y) __asm__ ("" "__fmin") __attribute__ ((__nothrow__));



extern int __fpclassifyl (long double __value) __asm__ ("" "__fpclassify") __attribute__ ((__nothrow__))
     __attribute__ ((__const__));


extern int __signbitl (long double __value) __asm__ ("" "__signbit") __attribute__ ((__nothrow__))
     __attribute__ ((__const__));



extern long double fmal (long double __x, long double __y, long double __z) __asm__ ("" "fma") __attribute__ ((__nothrow__)); extern long double __fmal (long double __x, long double __y, long double __z) __asm__ ("" "__fma") __attribute__ ((__nothrow__));








extern long double scalbl (long double __x, long double __n) __asm__ ("" "scalb") __attribute__ ((__nothrow__)); extern long double __scalbl (long double __x, long double __n) __asm__ ("" "__scalb") __attribute__ ((__nothrow__));
# 146 "/usr/include/math.h" 2 3 4
# 161 "/usr/include/math.h" 3 4
extern int signgam;
# 202 "/usr/include/math.h" 3 4
enum
  {
    FP_NAN,

    FP_INFINITE,

    FP_ZERO,

    FP_SUBNORMAL,

    FP_NORMAL

  };
# 295 "/usr/include/math.h" 3 4
typedef enum
{
  _IEEE_ = -1,
  _SVID_,
  _XOPEN_,
  _POSIX_,
  _ISOC_
} _LIB_VERSION_TYPE;




extern _LIB_VERSION_TYPE _LIB_VERSION;
# 320 "/usr/include/math.h" 3 4
struct exception

  {
    int type;
    char *name;
    double arg1;
    double arg2;
    double retval;
  };




extern int matherr (struct exception *__exc);
# 420 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathinline.h" 1 3 4
# 421 "/usr/include/math.h" 2 3 4
# 476 "/usr/include/math.h" 3 4

# 3 "../../fpu/softfloat-native.h" 2






# 1 "/usr/include/fenv.h" 1 3 4
# 58 "/usr/include/fenv.h" 3 4
# 1 "/usr/include/bits/fenv.h" 1 3 4
# 24 "/usr/include/bits/fenv.h" 3 4
enum
  {
    FE_INVALID = 1,

    FE_DIVBYZERO = 2,

    FE_OVERFLOW = 4,

    FE_UNDERFLOW = 8,

    FE_INEXACT = 16,

  };
# 46 "/usr/include/bits/fenv.h" 3 4
enum
  {
    FE_TONEAREST = 0,

    FE_UPWARD = 0x400000,

    FE_DOWNWARD = 0x800000,

    FE_TOWARDZERO = 0xc00000

  };


typedef unsigned int fexcept_t;


typedef struct
  {
    unsigned int __cw;
  }
fenv_t;
# 59 "/usr/include/fenv.h" 2 3 4






extern int feclearexcept (int __excepts) __attribute__ ((__nothrow__));



extern int fegetexceptflag (fexcept_t *__flagp, int __excepts) __attribute__ ((__nothrow__));


extern int feraiseexcept (int __excepts) __attribute__ ((__nothrow__));



extern int fesetexceptflag (__const fexcept_t *__flagp, int __excepts) __attribute__ ((__nothrow__));



extern int fetestexcept (int __excepts) __attribute__ ((__nothrow__));





extern int fegetround (void) __attribute__ ((__nothrow__));


extern int fesetround (int __rounding_direction) __attribute__ ((__nothrow__));






extern int fegetenv (fenv_t *__envp) __attribute__ ((__nothrow__));




extern int feholdexcept (fenv_t *__envp) __attribute__ ((__nothrow__));



extern int fesetenv (__const fenv_t *__envp) __attribute__ ((__nothrow__));




extern int feupdateenv (__const fenv_t *__envp) __attribute__ ((__nothrow__));




# 1 "/usr/include/bits/fenvinline.h" 1 3 4
# 116 "/usr/include/fenv.h" 2 3 4







extern int feenableexcept (int __excepts) __attribute__ ((__nothrow__));




extern int fedisableexcept (int __excepts) __attribute__ ((__nothrow__));


extern int fegetexcept (void) __attribute__ ((__nothrow__));



# 10 "../../fpu/softfloat-native.h" 2
# 89 "../../fpu/softfloat-native.h"
typedef float float32;
typedef double float64;




typedef union {
    float32 f;
    uint32_t i;
} float32u;
typedef union {
    float64 f;
    uint64_t i;
} float64u;
# 130 "../../fpu/softfloat-native.h"
enum {
    float_round_nearest_even = FE_TONEAREST,
    float_round_down = FE_DOWNWARD,
    float_round_up = FE_UPWARD,
    float_round_to_zero = FE_TOWARDZERO
};


typedef struct float_status {
    int float_rounding_mode;



} float_status;

void set_float_rounding_mode(int val , float_status *status);







float32 int32_to_float32( int , float_status *status);
float32 uint32_to_float32( unsigned int , float_status *status);
float64 int32_to_float64( int , float_status *status);
float64 uint32_to_float64( unsigned int , float_status *status);






float32 int64_to_float32( int64_t , float_status *status);
float32 uint64_to_float32( uint64_t , float_status *status);
float64 int64_to_float64( int64_t , float_status *status);
float64 uint64_to_float64( uint64_t v , float_status *status);
# 177 "../../fpu/softfloat-native.h"
int float32_to_int32( float32 , float_status *status);
int float32_to_int32_round_to_zero( float32 , float_status *status);
unsigned int float32_to_uint32( float32 a , float_status *status);
unsigned int float32_to_uint32_round_to_zero( float32 a , float_status *status);
int64_t float32_to_int64( float32 , float_status *status);
int64_t float32_to_int64_round_to_zero( float32 , float_status *status);
float64 float32_to_float64( float32 , float_status *status);
# 194 "../../fpu/softfloat-native.h"
float32 float32_round_to_int( float32 , float_status *status);
static __attribute__ (( always_inline )) __inline__ float32 float32_add( float32 a, float32 b , float_status *status)
{
    return a + b;
}
static __attribute__ (( always_inline )) __inline__ float32 float32_sub( float32 a, float32 b , float_status *status)
{
    return a - b;
}
static __attribute__ (( always_inline )) __inline__ float32 float32_mul( float32 a, float32 b , float_status *status)
{
    return a * b;
}
static __attribute__ (( always_inline )) __inline__ float32 float32_div( float32 a, float32 b , float_status *status)
{
    return a / b;
}
float32 float32_rem( float32, float32 , float_status *status);
float32 float32_sqrt( float32 , float_status *status);
static __attribute__ (( always_inline )) __inline__ int float32_eq( float32 a, float32 b , float_status *status)
{
    return a == b;
}
static __attribute__ (( always_inline )) __inline__ int float32_le( float32 a, float32 b , float_status *status)
{
    return a <= b;
}
static __attribute__ (( always_inline )) __inline__ int float32_lt( float32 a, float32 b , float_status *status)
{
    return a < b;
}
static __attribute__ (( always_inline )) __inline__ int float32_eq_signaling( float32 a, float32 b , float_status *status)
{
    return a <= b && a >= b;
}
static __attribute__ (( always_inline )) __inline__ int float32_le_quiet( float32 a, float32 b , float_status *status)
{
    return __builtin_islessequal(a, b);
}
static __attribute__ (( always_inline )) __inline__ int float32_lt_quiet( float32 a, float32 b , float_status *status)
{
    return __builtin_isless(a, b);
}
static __attribute__ (( always_inline )) __inline__ int float32_unordered( float32 a, float32 b , float_status *status)
{
    return __builtin_isunordered(a, b);

}
int float32_compare( float32, float32 , float_status *status );
int float32_compare_quiet( float32, float32 , float_status *status );
int float32_is_signaling_nan( float32 );
int float32_is_quiet_nan( float32 );

static __attribute__ (( always_inline )) __inline__ float32 float32_abs(float32 a)
{
    return fabsf(a);
}

static __attribute__ (( always_inline )) __inline__ float32 float32_chs(float32 a)
{
    return -a;
}

static __attribute__ (( always_inline )) __inline__ float32 float32_is_infinity(float32 a)
{
    return (sizeof (a) == sizeof (float) ? __fpclassifyf (a) : __fpclassify (a)) == FP_INFINITE;
}

static __attribute__ (( always_inline )) __inline__ float32 float32_is_neg(float32 a)
{
    float32u u;
    u.f = a;
    return u.i >> 31;
}

static __attribute__ (( always_inline )) __inline__ float32 float32_is_zero(float32 a)
{
    return (sizeof (a) == sizeof (float) ? __fpclassifyf (a) : __fpclassify (a)) == FP_ZERO;
}

static __attribute__ (( always_inline )) __inline__ float32 float32_scalbn(float32 a, int n)
{
    return scalbnf(a, n);
}




int float64_to_int32( float64 , float_status *status );
int float64_to_int32_round_to_zero( float64 , float_status *status );
unsigned int float64_to_uint32( float64 , float_status *status );
unsigned int float64_to_uint32_round_to_zero( float64 , float_status *status );
int64_t float64_to_int64( float64 , float_status *status );
int64_t float64_to_int64_round_to_zero( float64 , float_status *status );
uint64_t float64_to_uint64( float64 , float_status *status );
uint64_t float64_to_uint64_round_to_zero( float64 , float_status *status );
float32 float64_to_float32( float64 , float_status *status );
# 301 "../../fpu/softfloat-native.h"
float64 float64_round_to_int( float64 , float_status *status );
float64 float64_trunc_to_int( float64 , float_status *status );
static __attribute__ (( always_inline )) __inline__ float64 float64_add( float64 a, float64 b , float_status *status)
{
    return a + b;
}
static __attribute__ (( always_inline )) __inline__ float64 float64_sub( float64 a, float64 b , float_status *status)
{
    return a - b;
}
static __attribute__ (( always_inline )) __inline__ float64 float64_mul( float64 a, float64 b , float_status *status)
{
    return a * b;
}
static __attribute__ (( always_inline )) __inline__ float64 float64_div( float64 a, float64 b , float_status *status)
{
    return a / b;
}
float64 float64_rem( float64, float64 , float_status *status );
float64 float64_sqrt( float64 , float_status *status );
static __attribute__ (( always_inline )) __inline__ int float64_eq( float64 a, float64 b , float_status *status)
{
    return a == b;
}
static __attribute__ (( always_inline )) __inline__ int float64_le( float64 a, float64 b , float_status *status)
{
    return a <= b;
}
static __attribute__ (( always_inline )) __inline__ int float64_lt( float64 a, float64 b , float_status *status)
{
    return a < b;
}
static __attribute__ (( always_inline )) __inline__ int float64_eq_signaling( float64 a, float64 b , float_status *status)
{
    return a <= b && a >= b;
}
static __attribute__ (( always_inline )) __inline__ int float64_le_quiet( float64 a, float64 b , float_status *status)
{
    return __builtin_islessequal(a, b);
}
static __attribute__ (( always_inline )) __inline__ int float64_lt_quiet( float64 a, float64 b , float_status *status)
{
    return __builtin_isless(a, b);

}
static __attribute__ (( always_inline )) __inline__ int float64_unordered( float64 a, float64 b , float_status *status)
{
    return __builtin_isunordered(a, b);

}
int float64_compare( float64, float64 , float_status *status );
int float64_compare_quiet( float64, float64 , float_status *status );
int float64_is_signaling_nan( float64 );
int float64_is_quiet_nan( float64 );

static __attribute__ (( always_inline )) __inline__ float64 float64_abs(float64 a)
{
    return fabs(a);
}

static __attribute__ (( always_inline )) __inline__ float64 float64_chs(float64 a)
{
    return -a;
}

static __attribute__ (( always_inline )) __inline__ float64 float64_is_infinity(float64 a)
{
    return (sizeof (a) == sizeof (float) ? __fpclassifyf (a) : __fpclassify (a)) == FP_INFINITE;
}

static __attribute__ (( always_inline )) __inline__ float64 float64_is_neg(float64 a)
{
    float64u u;
    u.f = a;
    return u.i >> 63;
}

static __attribute__ (( always_inline )) __inline__ float64 float64_is_zero(float64 a)
{
    return (sizeof (a) == sizeof (float) ? __fpclassifyf (a) : __fpclassify (a)) == FP_ZERO;
}

static __attribute__ (( always_inline )) __inline__ float64 float64_scalbn(float64 a, int n)
{
    return scalbn(a, n);
}
# 580 "../../fpu/softfloat.h" 2
# 50 "../../target-i386/cpu.h" 2
# 469 "../../target-i386/cpu.h"
enum {
    CC_OP_DYNAMIC,
    CC_OP_EFLAGS,

    CC_OP_MULB,
    CC_OP_MULW,
    CC_OP_MULL,
    CC_OP_MULQ,

    CC_OP_ADDB,
    CC_OP_ADDW,
    CC_OP_ADDL,
    CC_OP_ADDQ,

    CC_OP_ADCB,
    CC_OP_ADCW,
    CC_OP_ADCL,
    CC_OP_ADCQ,

    CC_OP_SUBB,
    CC_OP_SUBW,
    CC_OP_SUBL,
    CC_OP_SUBQ,

    CC_OP_SBBB,
    CC_OP_SBBW,
    CC_OP_SBBL,
    CC_OP_SBBQ,

    CC_OP_LOGICB,
    CC_OP_LOGICW,
    CC_OP_LOGICL,
    CC_OP_LOGICQ,

    CC_OP_INCB,
    CC_OP_INCW,
    CC_OP_INCL,
    CC_OP_INCQ,

    CC_OP_DECB,
    CC_OP_DECW,
    CC_OP_DECL,
    CC_OP_DECQ,

    CC_OP_SHLB,
    CC_OP_SHLW,
    CC_OP_SHLL,
    CC_OP_SHLQ,

    CC_OP_SARB,
    CC_OP_SARW,
    CC_OP_SARL,
    CC_OP_SARQ,

    CC_OP_NB,
};
# 533 "../../target-i386/cpu.h"
typedef float64 CPU86_LDouble;


typedef struct SegmentCache {
    uint32_t selector;
    target_ulong base;
    uint32_t limit;
    uint32_t flags;
} SegmentCache;

typedef union {
    uint8_t _b[16];
    uint16_t _w[8];
    uint32_t _l[4];
    uint64_t _q[2];
    float32 _s[4];
    float64 _d[2];
} XMMReg;

typedef union {
    uint8_t _b[8];
    uint16_t _w[4];
    uint32_t _l[2];
    float32 _s[2];
    uint64_t q;
} MMXReg;
# 587 "../../target-i386/cpu.h"
typedef union {



    CPU86_LDouble d;

    MMXReg mmx;
} FPReg;

typedef struct {
    uint64_t base;
    uint64_t mask;
} MTRRVar;
# 612 "../../target-i386/cpu.h"
typedef struct CPUX86State {

    target_ulong regs[16];
    target_ulong eip;
    target_ulong eflags;




    target_ulong cc_src;
    target_ulong cc_dst;
    uint32_t cc_op;
    int32_t df;
    uint32_t hflags;

    uint32_t hflags2;


    SegmentCache segs[6];
    SegmentCache ldt;
    SegmentCache tr;
    SegmentCache gdt;
    SegmentCache idt;

    target_ulong cr[5];
    int32_t a20_mask;


    unsigned int fpstt;
    uint16_t fpus;
    uint16_t fpuc;
    uint8_t fptags[8];
    FPReg fpregs[8];


    float_status fp_status;
    CPU86_LDouble ft0;

    float_status mmx_status;
    float_status sse_status;
    uint32_t mxcsr;
    XMMReg xmm_regs[16];
    XMMReg xmm_t0;
    MMXReg mmx_t0;
    target_ulong cc_tmp;


    uint32_t sysenter_cs;
    target_ulong sysenter_esp;
    target_ulong sysenter_eip;
    uint64_t efer;
    uint64_t star;

    uint64_t vm_hsave;
    uint64_t vm_vmcb;
    uint64_t tsc_offset;
    uint64_t intercept;
    uint16_t intercept_cr_read;
    uint16_t intercept_cr_write;
    uint16_t intercept_dr_read;
    uint16_t intercept_dr_write;
    uint32_t intercept_exceptions;
    uint8_t v_tpr;


    target_ulong lstar;
    target_ulong cstar;
    target_ulong fmask;
    target_ulong kernelgsbase;

    uint64_t system_time_msr;
    uint64_t wall_clock_msr;
    uint64_t async_pf_en_msr;

    uint64_t tsc;

    uint64_t pat;


    int error_code;
    int exception_is_int;
    target_ulong exception_next_eip;
    target_ulong dr[8];
    union {
        CPUBreakpoint *cpu_breakpoint[4];
        CPUWatchpoint *cpu_watchpoint[4];
    };
    uint32_t smbase;
    int old_exception;

    struct TranslationBlock *current_tb; unsigned long mem_io_pc; target_ulong mem_io_vaddr; uint32_t halted; uint32_t interrupt_request; volatile sig_atomic_t exit_request; CPUTLBEntry tlb_table[2][(1 << 8)]; target_phys_addr_t iotlb[2][(1 << 8)]; target_ulong tlb_flush_addr; target_ulong tlb_flush_mask; struct TranslationBlock *tb_jmp_cache[(1 << 12)]; long temp_buf[128]; int64_t icount_extra; union { uint32_t u32; icount_decr_u16 u16; } icount_decr; uint32_t can_do_io; struct breakpoints_head { struct CPUBreakpoint *tqh_first; struct CPUBreakpoint * *tqh_last; } breakpoints; int singlestep_enabled; struct watchpoints_head { struct CPUWatchpoint *tqh_first; struct CPUWatchpoint * *tqh_last; } watchpoints; CPUWatchpoint *watchpoint_hit; struct GDBRegisterState *gdb_regs; jmp_buf jmp_env; int exception_index; struct CPUX86State *next_cpu; int cpu_index; uint32_t host_tid; int numa_node; int nr_cores; int nr_threads; int running; void *opaque; uint32_t created; uint32_t stop; uint32_t stopped; struct QemuThread *thread; struct QemuCond *halt_cond; struct qemu_work_item *queued_work_first, *queued_work_last; const char *cpu_model_str; struct KVMState *kvm_state; struct kvm_run *kvm_run; int kvm_fd; int kvm_vcpu_dirty;


    uint32_t cpuid_level;
    uint32_t cpuid_vendor1;
    uint32_t cpuid_vendor2;
    uint32_t cpuid_vendor3;
    uint32_t cpuid_version;
    uint32_t cpuid_features;
    uint32_t cpuid_ext_features;
    uint32_t cpuid_xlevel;
    uint32_t cpuid_model[12];
    uint32_t cpuid_ext2_features;
    uint32_t cpuid_ext3_features;
    uint32_t cpuid_apic_id;
    int cpuid_vendor_override;


    uint64_t mtrr_fixed[11];
    uint64_t mtrr_deftype;
    MTRRVar mtrr_var[8];


    uint32_t mp_state;
    int32_t exception_injected;
    int32_t interrupt_injected;
    uint8_t soft_interrupt;
    uint8_t nmi_injected;
    uint8_t nmi_pending;
    uint8_t has_error_code;
    uint32_t sipi_vector;
    uint32_t cpuid_kvm_features;
    uint32_t cpuid_svm_features;



    struct DeviceState *apic_state;

    uint64_t mcg_cap;
    uint64_t mcg_status;
    uint64_t mcg_ctl;
    uint64_t mce_banks[10*4];

    uint64_t tsc_aux;


    uint16_t fpus_vmstate;
    uint16_t fptag_vmstate;
    uint16_t fpregs_format_vmstate;

    uint64_t xstate_bv;
    XMMReg ymmh_regs[16];

    uint64_t xcr0;
} CPUX86State;

CPUX86State *cpu_x86_init(const char *cpu_model);
int cpu_x86_exec(CPUX86State *s);
void cpu_x86_close(CPUX86State *s);
void x86_cpu_list (FILE *f, fprintf_function cpu_fprintf, const char *optarg);
void x86_cpudef_setup(void);

int cpu_get_pic_interrupt(CPUX86State *s);

void cpu_set_ferr(CPUX86State *s);



static __attribute__ (( always_inline )) __inline__ void cpu_x86_load_seg_cache(CPUX86State *env,
                                          int seg_reg, unsigned int selector,
                                          target_ulong base,
                                          unsigned int limit,
                                          unsigned int flags)
{
    SegmentCache *sc;
    unsigned int new_hflags;

    sc = &env->segs[seg_reg];
    sc->selector = selector;
    sc->base = base;
    sc->limit = limit;
    sc->flags = flags;


    {
        if (seg_reg == 1) {

            if ((env->hflags & (1 << 14)) && (flags & (1 << 21))) {

                env->hflags |= (1 << 4) | (1 << 5) | (1 << 15);
                env->hflags &= ~((1 << 6));
            } else

            {

                new_hflags = (env->segs[1].flags & (1 << 22))
                    >> (22 - 4);
                env->hflags = (env->hflags & ~((1 << 4) | (1 << 15))) |
                    new_hflags;
            }
        }
        new_hflags = (env->segs[2].flags & (1 << 22))
            >> (22 - 5);
        if (env->hflags & (1 << 15)) {

        } else if (!(env->cr[0] & (1 << 0)) ||
                   (env->eflags & 0x00020000) ||
                   !(env->hflags & (1 << 4))) {





            new_hflags |= (1 << 6);
        } else {
            new_hflags |= ((env->segs[3].base |
                            env->segs[0].base |
                            env->segs[2].base) != 0) <<
                6;
        }
        env->hflags = (env->hflags &
                       ~((1 << 5) | (1 << 6))) | new_hflags;
    }
}

static __attribute__ (( always_inline )) __inline__ void cpu_x86_load_seg_cache_sipi(CPUX86State *env,
                                               int sipi_vector)
{
    env->eip = 0;
    cpu_x86_load_seg_cache(env, 1, sipi_vector << 8,
                           sipi_vector << 12,
                           env->segs[1].limit,
                           env->segs[1].flags);
    env->halted = 0;
}

int cpu_x86_get_descr_debug(CPUX86State *env, unsigned int selector,
                            target_ulong *base, unsigned int *limit,
                            unsigned int *flags);


static __attribute__ (( always_inline )) __inline__ void cpu_x86_set_cpl(CPUX86State *s, int cpl)
{

    s->hflags = (s->hflags & ~(3 << 0)) | cpl;



}



void cpu_get_fp80(uint64_t *pmant, uint16_t *pexp, CPU86_LDouble f);
CPU86_LDouble cpu_set_fp80(uint64_t mant, uint16_t upper);




void cpu_x86_load_seg(CPUX86State *s, int seg_reg, int selector);
void cpu_x86_fsave(CPUX86State *s, target_ulong ptr, int data32);
void cpu_x86_frstor(CPUX86State *s, target_ulong ptr, int data32);




int cpu_x86_signal_handler(int host_signum, void *pinfo,
                           void *puc);


void cpu_x86_cpuid(CPUX86State *env, uint32_t index, uint32_t count,
                   uint32_t *eax, uint32_t *ebx,
                   uint32_t *ecx, uint32_t *edx);
int cpu_x86_register (CPUX86State *env, const char *cpu_model);
void cpu_clear_apic_feature(CPUX86State *env);


int cpu_x86_handle_mmu_fault(CPUX86State *env, target_ulong addr,
                             int is_write, int mmu_idx, int is_softmmu);

void cpu_x86_set_a20(CPUX86State *env, int a20_state);

static __attribute__ (( always_inline )) __inline__ int hw_breakpoint_enabled(unsigned long dr7, int index)
{
    return (dr7 >> (index * 2)) & 3;
}

static __attribute__ (( always_inline )) __inline__ int hw_breakpoint_type(unsigned long dr7, int index)
{
    return (dr7 >> (16 + (index * 4))) & 3;
}

static __attribute__ (( always_inline )) __inline__ int hw_breakpoint_len(unsigned long dr7, int index)
{
    int len = ((dr7 >> (18 + (index * 4))) & 3);
    return (len == 2) ? 8 : len + 1;
}

void hw_breakpoint_insert(CPUX86State *env, int index);
void hw_breakpoint_remove(CPUX86State *env, int index);
int check_hw_breakpoints(CPUX86State *env, int force_dr6_update);


void cpu_x86_update_cr0(CPUX86State *env, uint32_t new_cr0);
void cpu_x86_update_cr3(CPUX86State *env, target_ulong new_cr3);
void cpu_x86_update_cr4(CPUX86State *env, uint32_t new_cr4);


void cpu_smm_update(CPUX86State *env);
uint64_t cpu_get_tsc(CPUX86State *env);
# 942 "../../target-i386/cpu.h"
static __attribute__ (( always_inline )) __inline__ int cpu_mmu_index (struct CPUX86State *env)
{
    return (env->hflags & (3 << 0)) == 3 ? 1 : 0;
}


void optimize_flags_init(void);

typedef struct CCTable {
    int (*compute_all)(void);
    int (*compute_c)(void);
} CCTable;
# 964 "../../target-i386/cpu.h"
# 1 "../../cpu-all.h" 1
# 22 "../../cpu-all.h"
# 1 "../../qemu-common.h" 1
# 23 "../../cpu-all.h" 2
# 1 "../../cpu-common.h" 1
# 18 "../../cpu-common.h"
# 1 "../../bswap.h" 1



# 1 "../config-host.h" 1
# 5 "../../bswap.h" 2
# 15 "../../bswap.h"
# 1 "/usr/include/byteswap.h" 1 3 4
# 23 "/usr/include/byteswap.h" 3 4
# 1 "/usr/include/bits/byteswap.h" 1 3 4
# 24 "/usr/include/byteswap.h" 2 3 4
# 16 "../../bswap.h" 2
# 52 "../../bswap.h"
static __attribute__ (( always_inline )) __inline__ uint16_t bswap16(uint16_t x)
{
    return (__extension__ ({ unsigned short int __bsx = (x); ((((__bsx) >> 8) & 0xffu) | (((__bsx) & 0xffu) << 8)); }));
}

static __attribute__ (( always_inline )) __inline__ uint32_t bswap32(uint32_t x)
{
    return (__extension__ ({ register unsigned int __bsx = (x); ((((__bsx) & 0xff000000u) >> 24) | (((__bsx) & 0x00ff0000u) >> 8) | (((__bsx) & 0x0000ff00u) << 8) | (((__bsx) & 0x000000ffu) << 24)); }));
}

static __attribute__ (( always_inline )) __inline__ uint64_t bswap64(uint64_t x)
{
    return (__extension__ ({ union { __extension__ unsigned long long int __ll; unsigned int __l[2]; } __w, __r; if (__builtin_constant_p (x)) __r.__ll = ((((x) & 0xff00000000000000ull) >> 56) | (((x) & 0x00ff000000000000ull) >> 40) | (((x) & 0x0000ff0000000000ull) >> 24) | (((x) & 0x000000ff00000000ull) >> 8) | (((x) & 0x00000000ff000000ull) << 8) | (((x) & 0x0000000000ff0000ull) << 24) | (((x) & 0x000000000000ff00ull) << 40) | (((x) & 0x00000000000000ffull) << 56)); else { __w.__ll = (x); __r.__l[0] = (__extension__ ({ register unsigned int __bsx = (__w.__l[1]); ((((__bsx) & 0xff000000u) >> 24) | (((__bsx) & 0x00ff0000u) >> 8) | (((__bsx) & 0x0000ff00u) << 8) | (((__bsx) & 0x000000ffu) << 24)); })); __r.__l[1] = (__extension__ ({ register unsigned int __bsx = (__w.__l[0]); ((((__bsx) & 0xff000000u) >> 24) | (((__bsx) & 0x00ff0000u) >> 8) | (((__bsx) & 0x0000ff00u) << 8) | (((__bsx) & 0x000000ffu) << 24)); })); } __r.__ll; }));
}



static __attribute__ (( always_inline )) __inline__ void bswap16s(uint16_t *s)
{
    *s = bswap16(*s);
}

static __attribute__ (( always_inline )) __inline__ void bswap32s(uint32_t *s)
{
    *s = bswap32(*s);
}

static __attribute__ (( always_inline )) __inline__ void bswap64s(uint64_t *s)
{
    *s = bswap64(*s);
}
# 127 "../../bswap.h"
static __attribute__ (( always_inline )) __inline__ uint16_t be16_to_cpu(uint16_t v){ return bswap16(v);}static __attribute__ (( always_inline )) __inline__ uint16_t cpu_to_be16(uint16_t v){ return bswap16(v);}static __attribute__ (( always_inline )) __inline__ void be16_to_cpus(uint16_t *p){ *p = bswap16(*p);}static __attribute__ (( always_inline )) __inline__ void cpu_to_be16s(uint16_t *p){ *p = bswap16(*p);}static __attribute__ (( always_inline )) __inline__ uint16_t be16_to_cpup(const uint16_t *p){ return be16_to_cpu(*p);}static __attribute__ (( always_inline )) __inline__ void cpu_to_be16w(uint16_t *p, uint16_t v){ *p = cpu_to_be16(v);}
static __attribute__ (( always_inline )) __inline__ uint32_t be32_to_cpu(uint32_t v){ return bswap32(v);}static __attribute__ (( always_inline )) __inline__ uint32_t cpu_to_be32(uint32_t v){ return bswap32(v);}static __attribute__ (( always_inline )) __inline__ void be32_to_cpus(uint32_t *p){ *p = bswap32(*p);}static __attribute__ (( always_inline )) __inline__ void cpu_to_be32s(uint32_t *p){ *p = bswap32(*p);}static __attribute__ (( always_inline )) __inline__ uint32_t be32_to_cpup(const uint32_t *p){ return be32_to_cpu(*p);}static __attribute__ (( always_inline )) __inline__ void cpu_to_be32w(uint32_t *p, uint32_t v){ *p = cpu_to_be32(v);}
static __attribute__ (( always_inline )) __inline__ uint64_t be64_to_cpu(uint64_t v){ return bswap64(v);}static __attribute__ (( always_inline )) __inline__ uint64_t cpu_to_be64(uint64_t v){ return bswap64(v);}static __attribute__ (( always_inline )) __inline__ void be64_to_cpus(uint64_t *p){ *p = bswap64(*p);}static __attribute__ (( always_inline )) __inline__ void cpu_to_be64s(uint64_t *p){ *p = bswap64(*p);}static __attribute__ (( always_inline )) __inline__ uint64_t be64_to_cpup(const uint64_t *p){ return be64_to_cpu(*p);}static __attribute__ (( always_inline )) __inline__ void cpu_to_be64w(uint64_t *p, uint64_t v){ *p = cpu_to_be64(v);}

static __attribute__ (( always_inline )) __inline__ uint16_t le16_to_cpu(uint16_t v){ return (v);}static __attribute__ (( always_inline )) __inline__ uint16_t cpu_to_le16(uint16_t v){ return (v);}static __attribute__ (( always_inline )) __inline__ void le16_to_cpus(uint16_t *p){ }static __attribute__ (( always_inline )) __inline__ void cpu_to_le16s(uint16_t *p){ }static __attribute__ (( always_inline )) __inline__ uint16_t le16_to_cpup(const uint16_t *p){ return le16_to_cpu(*p);}static __attribute__ (( always_inline )) __inline__ void cpu_to_le16w(uint16_t *p, uint16_t v){ *p = cpu_to_le16(v);}
static __attribute__ (( always_inline )) __inline__ uint32_t le32_to_cpu(uint32_t v){ return (v);}static __attribute__ (( always_inline )) __inline__ uint32_t cpu_to_le32(uint32_t v){ return (v);}static __attribute__ (( always_inline )) __inline__ void le32_to_cpus(uint32_t *p){ }static __attribute__ (( always_inline )) __inline__ void cpu_to_le32s(uint32_t *p){ }static __attribute__ (( always_inline )) __inline__ uint32_t le32_to_cpup(const uint32_t *p){ return le32_to_cpu(*p);}static __attribute__ (( always_inline )) __inline__ void cpu_to_le32w(uint32_t *p, uint32_t v){ *p = cpu_to_le32(v);}
static __attribute__ (( always_inline )) __inline__ uint64_t le64_to_cpu(uint64_t v){ return (v);}static __attribute__ (( always_inline )) __inline__ uint64_t cpu_to_le64(uint64_t v){ return (v);}static __attribute__ (( always_inline )) __inline__ void le64_to_cpus(uint64_t *p){ }static __attribute__ (( always_inline )) __inline__ void cpu_to_le64s(uint64_t *p){ }static __attribute__ (( always_inline )) __inline__ uint64_t le64_to_cpup(const uint64_t *p){ return le64_to_cpu(*p);}static __attribute__ (( always_inline )) __inline__ void cpu_to_le64w(uint64_t *p, uint64_t v){ *p = cpu_to_le64(v);}
# 151 "../../bswap.h"
static __attribute__ (( always_inline )) __inline__ void cpu_to_le16wu(uint16_t *p, uint16_t v)
{
    uint8_t *p1 = (uint8_t *)p;

    p1[0] = v & 0xff;
    p1[1] = v >> 8;
}

static __attribute__ (( always_inline )) __inline__ void cpu_to_le32wu(uint32_t *p, uint32_t v)
{
    uint8_t *p1 = (uint8_t *)p;

    p1[0] = v & 0xff;
    p1[1] = v >> 8;
    p1[2] = v >> 16;
    p1[3] = v >> 24;
}

static __attribute__ (( always_inline )) __inline__ uint16_t le16_to_cpupu(const uint16_t *p)
{
    const uint8_t *p1 = (const uint8_t *)p;
    return p1[0] | (p1[1] << 8);
}

static __attribute__ (( always_inline )) __inline__ uint32_t le32_to_cpupu(const uint32_t *p)
{
    const uint8_t *p1 = (const uint8_t *)p;
    return p1[0] | (p1[1] << 8) | (p1[2] << 16) | (p1[3] << 24);
}

static __attribute__ (( always_inline )) __inline__ uint32_t be32_to_cpupu(const uint32_t *p)
{
    const uint8_t *p1 = (const uint8_t *)p;
    return p1[3] | (p1[2] << 8) | (p1[1] << 16) | (p1[0] << 24);
}

static __attribute__ (( always_inline )) __inline__ void cpu_to_be16wu(uint16_t *p, uint16_t v)
{
    uint8_t *p1 = (uint8_t *)p;

    p1[0] = v >> 8;
    p1[1] = v & 0xff;
}

static __attribute__ (( always_inline )) __inline__ void cpu_to_be32wu(uint32_t *p, uint32_t v)
{
    uint8_t *p1 = (uint8_t *)p;

    p1[0] = v >> 24;
    p1[1] = v >> 16;
    p1[2] = v >> 8;
    p1[3] = v & 0xff;
}

static __attribute__ (( always_inline )) __inline__ void cpu_to_be64wu(uint64_t *p, uint64_t v)
{
    uint8_t *p1 = (uint8_t *)p;

    p1[0] = v >> 56;
    p1[1] = v >> 48;
    p1[2] = v >> 40;
    p1[3] = v >> 32;
    p1[4] = v >> 24;
    p1[5] = v >> 16;
    p1[6] = v >> 8;
    p1[7] = v & 0xff;
}
# 235 "../../bswap.h"
static __attribute__ (( always_inline )) __inline__ uint32_t qemu_bswap_len(uint32_t value, int len)
{
    return bswap32(value) >> (32 - 8 * len);
}
# 19 "../../cpu-common.h" 2




enum device_endian {
    DEVICE_NATIVE_ENDIAN,
    DEVICE_BIG_ENDIAN,
    DEVICE_LITTLE_ENDIAN,
};


typedef unsigned long ram_addr_t;



typedef void CPUWriteMemoryFunc(void *opaque, target_phys_addr_t addr, uint32_t value);
typedef uint32_t CPUReadMemoryFunc(void *opaque, target_phys_addr_t addr);

void cpu_register_physical_memory_offset(target_phys_addr_t start_addr,
                                         ram_addr_t size,
                                         ram_addr_t phys_offset,
                                         ram_addr_t region_offset);
static __attribute__ (( always_inline )) __inline__ void cpu_register_physical_memory(target_phys_addr_t start_addr,
                                                ram_addr_t size,
                                                ram_addr_t phys_offset)
{
    cpu_register_physical_memory_offset(start_addr, size, phys_offset, 0);
}

ram_addr_t cpu_get_physical_page_desc(target_phys_addr_t addr);
ram_addr_t qemu_ram_alloc_from_ptr(DeviceState *dev, const char *name,
                        ram_addr_t size, void *host);
ram_addr_t qemu_ram_alloc(DeviceState *dev, const char *name, ram_addr_t size);
void qemu_ram_free(ram_addr_t addr);

void *qemu_get_ram_ptr(ram_addr_t addr);


void *qemu_safe_ram_ptr(ram_addr_t addr);

int qemu_ram_addr_from_host(void *ptr, ram_addr_t *ram_addr);
ram_addr_t qemu_ram_addr_from_host_nofail(void *ptr);

int cpu_register_io_memory(CPUReadMemoryFunc * const *mem_read,
                           CPUWriteMemoryFunc * const *mem_write,
                           void *opaque, enum device_endian endian);
void cpu_unregister_io_memory(int table_address);

void cpu_physical_memory_rw(target_phys_addr_t addr, uint8_t *buf,
                            int len, int is_write);
static __attribute__ (( always_inline )) __inline__ void cpu_physical_memory_read(target_phys_addr_t addr,
                                            uint8_t *buf, int len)
{
    cpu_physical_memory_rw(addr, buf, len, 0);
}
static __attribute__ (( always_inline )) __inline__ void cpu_physical_memory_write(target_phys_addr_t addr,
                                             const uint8_t *buf, int len)
{
    cpu_physical_memory_rw(addr, (uint8_t *)buf, len, 1);
}
void *cpu_physical_memory_map(target_phys_addr_t addr,
                              target_phys_addr_t *plen,
                              int is_write);
void cpu_physical_memory_unmap(void *buffer, target_phys_addr_t len,
                               int is_write, target_phys_addr_t access_len);
void *cpu_register_map_client(void *opaque, void (*callback)(void *opaque));
void cpu_unregister_map_client(void *cookie);

struct CPUPhysMemoryClient;
typedef struct CPUPhysMemoryClient CPUPhysMemoryClient;
struct CPUPhysMemoryClient {
    void (*set_memory)(struct CPUPhysMemoryClient *client,
                       target_phys_addr_t start_addr,
                       ram_addr_t size,
                       ram_addr_t phys_offset);
    int (*sync_dirty_bitmap)(struct CPUPhysMemoryClient *client,
                             target_phys_addr_t start_addr,
                             target_phys_addr_t end_addr);
    int (*migration_log)(struct CPUPhysMemoryClient *client,
                         int enable);
    struct { struct CPUPhysMemoryClient *le_next; struct CPUPhysMemoryClient **le_prev; } list;
};

void cpu_register_phys_memory_client(CPUPhysMemoryClient *);
void cpu_unregister_phys_memory_client(CPUPhysMemoryClient *);






void qemu_register_coalesced_mmio(target_phys_addr_t addr, ram_addr_t size);

void qemu_unregister_coalesced_mmio(target_phys_addr_t addr, ram_addr_t size);

void qemu_flush_coalesced_mmio_buffer(void);

uint32_t ldub_phys(target_phys_addr_t addr);
uint32_t lduw_phys(target_phys_addr_t addr);
uint32_t ldl_phys(target_phys_addr_t addr);
uint64_t ldq_phys(target_phys_addr_t addr);
void stl_phys_notdirty(target_phys_addr_t addr, uint32_t val);
void stq_phys_notdirty(target_phys_addr_t addr, uint64_t val);
void stb_phys(target_phys_addr_t addr, uint32_t val);
void stw_phys(target_phys_addr_t addr, uint32_t val);
void stl_phys(target_phys_addr_t addr, uint32_t val);
void stq_phys(target_phys_addr_t addr, uint64_t val);

void cpu_physical_memory_write_rom(target_phys_addr_t addr,
                                   const uint8_t *buf, int len);
# 24 "../../cpu-all.h" 2
# 78 "../../cpu-all.h"
static __attribute__ (( always_inline )) __inline__ uint16_t tswap16(uint16_t s)
{
    return s;
}

static __attribute__ (( always_inline )) __inline__ uint32_t tswap32(uint32_t s)
{
    return s;
}

static __attribute__ (( always_inline )) __inline__ uint64_t tswap64(uint64_t s)
{
    return s;
}

static __attribute__ (( always_inline )) __inline__ void tswap16s(uint16_t *s)
{
}

static __attribute__ (( always_inline )) __inline__ void tswap32s(uint32_t *s)
{
}

static __attribute__ (( always_inline )) __inline__ void tswap64s(uint64_t *s)
{
}
# 117 "../../cpu-all.h"
typedef union {
    float32 f;
    uint32_t l;
} CPU_FloatU;



typedef union {
    float64 d;







    struct {
        uint32_t lower;
        uint32_t upper;
    } l;

    uint64_t ll;
} CPU_DoubleU;
# 206 "../../cpu-all.h"
static __attribute__ (( always_inline )) __inline__ int ldub_p(const void *ptr)
{
    return *(uint8_t *)ptr;
}

static __attribute__ (( always_inline )) __inline__ int ldsb_p(const void *ptr)
{
    return *(int8_t *)ptr;
}

static __attribute__ (( always_inline )) __inline__ void stb_p(void *ptr, int v)
{
    *(uint8_t *)ptr = v;
}







static __attribute__ (( always_inline )) __inline__ int lduw_le_p(const void *ptr)
{





    const uint8_t *p = ptr;
    return p[0] | (p[1] << 8);

}

static __attribute__ (( always_inline )) __inline__ int ldsw_le_p(const void *ptr)
{





    const uint8_t *p = ptr;
    return (int16_t)(p[0] | (p[1] << 8));

}

static __attribute__ (( always_inline )) __inline__ int ldl_le_p(const void *ptr)
{





    const uint8_t *p = ptr;
    return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);

}

static __attribute__ (( always_inline )) __inline__ uint64_t ldq_le_p(const void *ptr)
{
    const uint8_t *p = ptr;
    uint32_t v1, v2;
    v1 = ldl_le_p(p);
    v2 = ldl_le_p(p + 4);
    return v1 | ((uint64_t)v2 << 32);
}

static __attribute__ (( always_inline )) __inline__ void stw_le_p(void *ptr, int v)
{



    uint8_t *p = ptr;
    p[0] = v;
    p[1] = v >> 8;

}

static __attribute__ (( always_inline )) __inline__ void stl_le_p(void *ptr, int v)
{



    uint8_t *p = ptr;
    p[0] = v;
    p[1] = v >> 8;
    p[2] = v >> 16;
    p[3] = v >> 24;

}

static __attribute__ (( always_inline )) __inline__ void stq_le_p(void *ptr, uint64_t v)
{
    uint8_t *p = ptr;
    stl_le_p(p, (uint32_t)v);
    stl_le_p(p + 4, v >> 32);
}



static __attribute__ (( always_inline )) __inline__ float32 ldfl_le_p(const void *ptr)
{
    union {
        float32 f;
        uint32_t i;
    } u;
    u.i = ldl_le_p(ptr);
    return u.f;
}

static __attribute__ (( always_inline )) __inline__ void stfl_le_p(void *ptr, float32 v)
{
    union {
        float32 f;
        uint32_t i;
    } u;
    u.f = v;
    stl_le_p(ptr, u.i);
}

static __attribute__ (( always_inline )) __inline__ float64 ldfq_le_p(const void *ptr)
{
    CPU_DoubleU u;
    u.l.lower = ldl_le_p(ptr);
    u.l.upper = ldl_le_p(ptr + 4);
    return u.d;
}

static __attribute__ (( always_inline )) __inline__ void stfq_le_p(void *ptr, float64 v)
{
    CPU_DoubleU u;
    u.d = v;
    stl_le_p(ptr, u.l.lower);
    stl_le_p(ptr + 4, u.l.upper);
}
# 403 "../../cpu-all.h"
static __attribute__ (( always_inline )) __inline__ int lduw_be_p(const void *ptr)
{
# 413 "../../cpu-all.h"
    const uint8_t *b = ptr;
    return ((b[0] << 8) | b[1]);

}

static __attribute__ (( always_inline )) __inline__ int ldsw_be_p(const void *ptr)
{
# 428 "../../cpu-all.h"
    const uint8_t *b = ptr;
    return (int16_t)((b[0] << 8) | b[1]);

}

static __attribute__ (( always_inline )) __inline__ int ldl_be_p(const void *ptr)
{
# 443 "../../cpu-all.h"
    const uint8_t *b = ptr;
    return (b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3];

}

static __attribute__ (( always_inline )) __inline__ uint64_t ldq_be_p(const void *ptr)
{
    uint32_t a,b;
    a = ldl_be_p(ptr);
    b = ldl_be_p((uint8_t *)ptr + 4);
    return (((uint64_t)a<<32)|b);
}

static __attribute__ (( always_inline )) __inline__ void stw_be_p(void *ptr, int v)
{






    uint8_t *d = (uint8_t *) ptr;
    d[0] = v >> 8;
    d[1] = v;

}

static __attribute__ (( always_inline )) __inline__ void stl_be_p(void *ptr, int v)
{






    uint8_t *d = (uint8_t *) ptr;
    d[0] = v >> 24;
    d[1] = v >> 16;
    d[2] = v >> 8;
    d[3] = v;

}

static __attribute__ (( always_inline )) __inline__ void stq_be_p(void *ptr, uint64_t v)
{
    stl_be_p(ptr, v >> 32);
    stl_be_p((uint8_t *)ptr + 4, v);
}



static __attribute__ (( always_inline )) __inline__ float32 ldfl_be_p(const void *ptr)
{
    union {
        float32 f;
        uint32_t i;
    } u;
    u.i = ldl_be_p(ptr);
    return u.f;
}

static __attribute__ (( always_inline )) __inline__ void stfl_be_p(void *ptr, float32 v)
{
    union {
        float32 f;
        uint32_t i;
    } u;
    u.f = v;
    stl_be_p(ptr, u.i);
}

static __attribute__ (( always_inline )) __inline__ float64 ldfq_be_p(const void *ptr)
{
    CPU_DoubleU u;
    u.l.upper = ldl_be_p(ptr);
    u.l.lower = ldl_be_p((uint8_t *)ptr + 4);
    return u.d;
}

static __attribute__ (( always_inline )) __inline__ void stfq_be_p(void *ptr, float64 v)
{
    CPU_DoubleU u;
    u.d = v;
    stl_be_p(ptr, u.l.upper);
    stl_be_p((uint8_t *)ptr + 4, u.l.lower);
}
# 732 "../../cpu-all.h"
extern unsigned long qemu_real_host_page_size;
extern unsigned long qemu_host_page_bits;
extern unsigned long qemu_host_page_size;
extern unsigned long qemu_host_page_mask;
# 765 "../../cpu-all.h"
struct CPUX86State *cpu_copy(struct CPUX86State *env);
struct CPUX86State *qemu_get_cpu(int cpu);

void cpu_dump_state(struct CPUX86State *env, FILE *f, fprintf_function cpu_fprintf,
                    int flags);
void cpu_dump_statistics(struct CPUX86State *env, FILE *f, fprintf_function cpu_fprintf,
                         int flags);

void __attribute__ ((__noreturn__)) cpu_abort(struct CPUX86State *env, const char *fmt, ...)
    __attribute__((format(gnu_printf, 2, 3)));
extern struct CPUX86State *first_cpu;
extern struct CPUX86State *cpu_single_env;
# 791 "../../cpu-all.h"
void cpu_interrupt(struct CPUX86State *s, int mask);
void cpu_reset_interrupt(struct CPUX86State *env, int mask);

void cpu_exit(struct CPUX86State *s);

int qemu_cpu_has_work(struct CPUX86State *env);
# 807 "../../cpu-all.h"
int cpu_breakpoint_insert(struct CPUX86State *env, target_ulong pc, int flags,
                          CPUBreakpoint **breakpoint);
int cpu_breakpoint_remove(struct CPUX86State *env, target_ulong pc, int flags);
void cpu_breakpoint_remove_by_ref(struct CPUX86State *env, CPUBreakpoint *breakpoint);
void cpu_breakpoint_remove_all(struct CPUX86State *env, int mask);
int cpu_watchpoint_insert(struct CPUX86State *env, target_ulong addr, target_ulong len,
                          int flags, CPUWatchpoint **watchpoint);
int cpu_watchpoint_remove(struct CPUX86State *env, target_ulong addr,
                          target_ulong len, int flags);
void cpu_watchpoint_remove_by_ref(struct CPUX86State *env, CPUWatchpoint *watchpoint);
void cpu_watchpoint_remove_all(struct CPUX86State *env, int mask);





void cpu_single_step(struct CPUX86State *env, int enabled);
void cpu_reset(struct CPUX86State *s);
int cpu_is_stopped(struct CPUX86State *env);
void run_on_cpu(struct CPUX86State *env, void (*func)(void *data), void *data);
# 840 "../../cpu-all.h"
typedef struct CPULogItem {
    int mask;
    const char *name;
    const char *help;
} CPULogItem;

extern const CPULogItem cpu_log_items[];

void cpu_set_log(int log_flags);
void cpu_set_log_filename(const char *filename);
int cpu_str_to_log_mask(const char *str);






target_phys_addr_t cpu_get_phys_page_debug(struct CPUX86State *env, target_ulong addr);



extern int phys_ram_fd;
extern ram_addr_t ram_size;

typedef struct RAMBlock {
    uint8_t *host;
    ram_addr_t offset;
    ram_addr_t length;
    char idstr[256];
    struct { struct RAMBlock *le_next; struct RAMBlock **le_prev; } next;

    int fd;

} RAMBlock;

typedef struct RAMList {
    uint8_t *phys_dirty;
    struct ram { struct RAMBlock *lh_first; } blocks;
} RAMList;
extern RAMList ram_list;

extern const char *mem_path;
extern int mem_prealloc;
# 907 "../../cpu-all.h"
static __attribute__ (( always_inline )) __inline__ int cpu_physical_memory_is_dirty(ram_addr_t addr)
{
    return ram_list.phys_dirty[addr >> 12] == 0xff;
}

static __attribute__ (( always_inline )) __inline__ int cpu_physical_memory_get_dirty_flags(ram_addr_t addr)
{
    return ram_list.phys_dirty[addr >> 12];
}

static __attribute__ (( always_inline )) __inline__ int cpu_physical_memory_get_dirty(ram_addr_t addr,
                                                int dirty_flags)
{
    return ram_list.phys_dirty[addr >> 12] & dirty_flags;
}

static __attribute__ (( always_inline )) __inline__ void cpu_physical_memory_set_dirty(ram_addr_t addr)
{
    ram_list.phys_dirty[addr >> 12] = 0xff;
}

static __attribute__ (( always_inline )) __inline__ int cpu_physical_memory_set_dirty_flags(ram_addr_t addr,
                                                      int dirty_flags)
{
    return ram_list.phys_dirty[addr >> 12] |= dirty_flags;
}

static __attribute__ (( always_inline )) __inline__ void cpu_physical_memory_mask_dirty_range(ram_addr_t start,
                                                        int length,
                                                        int dirty_flags)
{
    int i, mask, len;
    uint8_t *p;

    len = length >> 12;
    mask = ~dirty_flags;
    p = ram_list.phys_dirty + (start >> 12);
    for (i = 0; i < len; i++) {
        p[i] &= mask;
    }
}

void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t end,
                                     int dirty_flags);
void cpu_tlb_update_dirty(struct CPUX86State *env);

int cpu_physical_memory_set_dirty_tracking(int enable);

int cpu_physical_memory_get_dirty_tracking(void);

int cpu_physical_sync_dirty_bitmap(target_phys_addr_t start_addr,
                                   target_phys_addr_t end_addr);

void dump_exec_info(FILE *f, fprintf_function cpu_fprintf);


int cpu_memory_rw_debug(struct CPUX86State *env, target_ulong addr,
                        uint8_t *buf, int len, int is_write);

void cpu_inject_x86_mce(struct CPUX86State *cenv, int bank, uint64_t status,
                        uint64_t mcg_status, uint64_t addr, uint64_t misc);
# 965 "../../target-i386/cpu.h" 2
# 1 "../../target-i386/svm.h" 1
# 133 "../../target-i386/svm.h"
struct __attribute__ ((__packed__)) vmcb_control_area {
 uint16_t intercept_cr_read;
 uint16_t intercept_cr_write;
 uint16_t intercept_dr_read;
 uint16_t intercept_dr_write;
 uint32_t intercept_exceptions;
 uint64_t intercept;
 uint8_t reserved_1[44];
 uint64_t iopm_base_pa;
 uint64_t msrpm_base_pa;
 uint64_t tsc_offset;
 uint32_t asid;
 uint8_t tlb_ctl;
 uint8_t reserved_2[3];
 uint32_t int_ctl;
 uint32_t int_vector;
 uint32_t int_state;
 uint8_t reserved_3[4];
 uint64_t exit_code;
 uint64_t exit_info_1;
 uint64_t exit_info_2;
 uint32_t exit_int_info;
 uint32_t exit_int_info_err;
 uint64_t nested_ctl;
 uint8_t reserved_4[16];
 uint32_t event_inj;
 uint32_t event_inj_err;
 uint64_t nested_cr3;
 uint64_t lbr_ctl;
 uint8_t reserved_5[832];
};

struct __attribute__ ((__packed__)) vmcb_seg {
 uint16_t selector;
 uint16_t attrib;
 uint32_t limit;
 uint64_t base;
};

struct __attribute__ ((__packed__)) vmcb_save_area {
 struct vmcb_seg es;
 struct vmcb_seg cs;
 struct vmcb_seg ss;
 struct vmcb_seg ds;
 struct vmcb_seg fs;
 struct vmcb_seg gs;
 struct vmcb_seg gdtr;
 struct vmcb_seg ldtr;
 struct vmcb_seg idtr;
 struct vmcb_seg tr;
 uint8_t reserved_1[43];
 uint8_t cpl;
 uint8_t reserved_2[4];
 uint64_t efer;
 uint8_t reserved_3[112];
 uint64_t cr4;
 uint64_t cr3;
 uint64_t cr0;
 uint64_t dr7;
 uint64_t dr6;
 uint64_t rflags;
 uint64_t rip;
 uint8_t reserved_4[88];
 uint64_t rsp;
 uint8_t reserved_5[24];
 uint64_t rax;
 uint64_t star;
 uint64_t lstar;
 uint64_t cstar;
 uint64_t sfmask;
 uint64_t kernel_gs_base;
 uint64_t sysenter_cs;
 uint64_t sysenter_esp;
 uint64_t sysenter_eip;
 uint64_t cr2;
 uint8_t reserved_6[32];
 uint64_t g_pat;
 uint64_t dbgctl;
 uint64_t br_from;
 uint64_t br_to;
 uint64_t last_excp_from;
 uint64_t last_excp_to;
};

struct __attribute__ ((__packed__)) vmcb {
 struct vmcb_control_area control;
 struct vmcb_save_area save;
};
# 966 "../../target-i386/cpu.h" 2


# 1 "../../hw/apic.h" 1






void apic_deliver_irq(uint8_t dest, uint8_t dest_mode,
                             uint8_t delivery_mode,
                             uint8_t vector_num, uint8_t polarity,
                             uint8_t trigger_mode);
int apic_accept_pic_intr(DeviceState *s);
void apic_deliver_pic_intr(DeviceState *s, int level);
int apic_get_interrupt(DeviceState *s);
void apic_reset_irq_delivered(void);
int apic_get_irq_delivered(void);
void cpu_set_apic_base(DeviceState *s, uint64_t val);
uint64_t cpu_get_apic_base(DeviceState *s);
void cpu_set_apic_tpr(DeviceState *s, uint8_t val);
uint8_t cpu_get_apic_tpr(DeviceState *s);
void apic_init_reset(DeviceState *s);
void apic_sipi(DeviceState *s);


int cpu_is_bsp(struct CPUX86State *env);
DeviceState *cpu_get_current_apic(void);
# 969 "../../target-i386/cpu.h" 2


static __attribute__ (( always_inline )) __inline__ void cpu_get_tb_cpu_state(struct CPUX86State *env, target_ulong *pc,
                                        target_ulong *cs_base, int *flags)
{
    *cs_base = env->segs[1].base;
    *pc = *cs_base + env->eip;
    *flags = env->hflags |
        (env->eflags & (0x00003000 | 0x00000100 | 0x00010000 | 0x00020000));
}

void do_cpu_init(struct CPUX86State *env);
void do_cpu_sipi(struct CPUX86State *env);
# 27 "../../target-i386/translate.c" 2
# 1 "../../exec-all.h" 1
# 34 "../../exec-all.h"
typedef ram_addr_t tb_page_addr_t;
# 43 "../../exec-all.h"
typedef struct TranslationBlock TranslationBlock;
# 72 "../../exec-all.h"
extern target_ulong gen_opc_pc[640];
extern uint8_t gen_opc_instr_start[640];
extern uint16_t gen_opc_icount[640];

# 1 "../../qemu-log.h" 1




extern FILE *logfile;
extern int loglevel;
# 77 "../../exec-all.h" 2

void gen_intermediate_code(struct CPUX86State *env, struct TranslationBlock *tb);
void gen_intermediate_code_pc(struct CPUX86State *env, struct TranslationBlock *tb);
void gen_pc_load(struct CPUX86State *env, struct TranslationBlock *tb,
                 unsigned long searched_pc, int pc_pos, void *puc);

void cpu_gen_init(void);
int cpu_x86_gen_code(struct CPUX86State *env, struct TranslationBlock *tb,
                 int *gen_code_size_ptr);
int cpu_restore_state(struct TranslationBlock *tb,
                      struct CPUX86State *env, unsigned long searched_pc,
                      void *puc);
void cpu_resume_from_signal(struct CPUX86State *env1, void *puc);
void cpu_io_recompile(struct CPUX86State *env, void *retaddr);
TranslationBlock *tb_gen_code(struct CPUX86State *env,
                              target_ulong pc, target_ulong cs_base, int flags,
                              int cflags);
void cpu_exec_init(struct CPUX86State *env);
void __attribute__ ((__noreturn__)) cpu_loop_exit(void);
int page_unprotect(target_ulong address, unsigned long pc, void *puc);
void tb_invalidate_phys_page_range(tb_page_addr_t start, tb_page_addr_t end,
                                   int is_cpu_write_access);
void tb_invalidate_page_range(target_ulong start, target_ulong end);
void tlb_flush_page(struct CPUX86State *env, target_ulong addr);
void tlb_flush(struct CPUX86State *env, int flush_global);

void tlb_set_page(struct CPUX86State *env, target_ulong vaddr,
                  target_phys_addr_t paddr, int prot,
                  int mmu_idx, target_ulong size);
# 128 "../../exec-all.h"
struct TranslationBlock {
    target_ulong pc;
    target_ulong cs_base;
    uint64_t flags;
    uint16_t size;

    uint16_t cflags;



    uint8_t *tc_ptr;

    struct TranslationBlock *phys_hash_next;


    struct TranslationBlock *page_next[2];
    tb_page_addr_t page_addr[2];



    uint16_t tb_next_offset[2];

    uint16_t tb_jmp_offset[2];







    struct TranslationBlock *jmp_next[2];
    struct TranslationBlock *jmp_first;
    uint32_t icount;
};

static __attribute__ (( always_inline )) __inline__ unsigned int tb_jmp_cache_hash_page(target_ulong pc)
{
    target_ulong tmp;
    tmp = pc ^ (pc >> (12 - (12 / 2)));
    return (tmp >> (12 - (12 / 2))) & ((1 << 12) - (1 << (12 / 2)));
}

static __attribute__ (( always_inline )) __inline__ unsigned int tb_jmp_cache_hash_func(target_ulong pc)
{
    target_ulong tmp;
    tmp = pc ^ (pc >> (12 - (12 / 2)));
    return (((tmp >> (12 - (12 / 2))) & ((1 << 12) - (1 << (12 / 2))))
     | (tmp & ((1 << (12 / 2)) - 1)));
}

static __attribute__ (( always_inline )) __inline__ unsigned int tb_phys_hash_func(tb_page_addr_t pc)
{
    return (pc >> 2) & ((1 << 15) - 1);
}

TranslationBlock *tb_alloc(target_ulong pc);
void tb_free(TranslationBlock *tb);
void tb_flush(struct CPUX86State *env);
void tb_link_page(TranslationBlock *tb,
                  tb_page_addr_t phys_pc, tb_page_addr_t phys_page2);
void tb_phys_invalidate(TranslationBlock *tb, tb_page_addr_t page_addr);

extern TranslationBlock *tb_phys_hash[(1 << 15)];
# 205 "../../exec-all.h"
static __attribute__ (( always_inline )) __inline__ void tb_set_jmp_target1(unsigned long jmp_addr, unsigned long addr)
{







    *(uint32_t *)jmp_addr =
        (*(uint32_t *)jmp_addr & ~0xffffff)
        | (((addr - (jmp_addr + 8)) >> 2) & 0xffffff);


    __builtin___clear_cache((char *) jmp_addr, (char *) jmp_addr + 4);







}


static __attribute__ (( always_inline )) __inline__ void tb_set_jmp_target(TranslationBlock *tb,
                                     int n, unsigned long addr)
{
    unsigned long offset;

    offset = tb->tb_jmp_offset[n];
    tb_set_jmp_target1((unsigned long)(tb->tc_ptr + offset), addr);
}
# 250 "../../exec-all.h"
static __attribute__ (( always_inline )) __inline__ void tb_add_jump(TranslationBlock *tb, int n,
                               TranslationBlock *tb_next)
{

    if (!tb->jmp_next[n]) {

        tb_set_jmp_target(tb, n, (unsigned long)tb_next->tc_ptr);


        tb->jmp_next[n] = tb_next->jmp_first;
        tb_next->jmp_first = (TranslationBlock *)((long)(tb) | (n));
    }
}

TranslationBlock *tb_find_pc(unsigned long pc_ptr);

# 1 "../../qemu-lock.h" 1
# 38 "../../qemu-lock.h"
typedef int spinlock_t;


static __attribute__ (( always_inline )) __inline__ void spin_lock(spinlock_t *lock)
{
}

static __attribute__ (( always_inline )) __inline__ void spin_unlock(spinlock_t *lock)
{
}
# 267 "../../exec-all.h" 2

extern spinlock_t tb_lock;

extern int tb_invalidated_flag;



extern CPUWriteMemoryFunc *io_mem_write[(1 << (12 - 3))][4];
extern CPUReadMemoryFunc *io_mem_read[(1 << (12 - 3))][4];
extern void *io_mem_opaque[(1 << (12 - 3))];

void tlb_fill(target_ulong addr, int is_write, int mmu_idx,
              void *retaddr);

# 1 "../../softmmu_defs.h" 1



uint8_t __ldb_mmu(target_ulong addr, int mmu_idx);
void __stb_mmu(target_ulong addr, uint8_t val, int mmu_idx);
uint16_t __ldw_mmu(target_ulong addr, int mmu_idx);
void __stw_mmu(target_ulong addr, uint16_t val, int mmu_idx);
uint32_t __ldl_mmu(target_ulong addr, int mmu_idx);
void __stl_mmu(target_ulong addr, uint32_t val, int mmu_idx);
uint64_t __ldq_mmu(target_ulong addr, int mmu_idx);
void __stq_mmu(target_ulong addr, uint64_t val, int mmu_idx);

uint8_t __ldb_cmmu(target_ulong addr, int mmu_idx);
void __stb_cmmu(target_ulong addr, uint8_t val, int mmu_idx);
uint16_t __ldw_cmmu(target_ulong addr, int mmu_idx);
void __stw_cmmu(target_ulong addr, uint16_t val, int mmu_idx);
uint32_t __ldl_cmmu(target_ulong addr, int mmu_idx);
void __stl_cmmu(target_ulong addr, uint32_t val, int mmu_idx);
uint64_t __ldq_cmmu(target_ulong addr, int mmu_idx);
void __stq_cmmu(target_ulong addr, uint64_t val, int mmu_idx);
# 282 "../../exec-all.h" 2






# 1 "../../softmmu_header.h" 1
# 74 "../../softmmu_header.h"
static __attribute__ (( always_inline )) __inline__ uint32_t ldub_code(target_ulong ptr)
{
    int page_index;
    uint32_t res;
    target_ulong addr;
    unsigned long physaddr;
    int mmu_idx;

    addr = ptr;
    page_index = (addr >> 12) & ((1 << 8) - 1);
    mmu_idx = (cpu_mmu_index(cpu_single_env));
    if (__builtin_expect(!!(cpu_single_env->tlb_table[mmu_idx][page_index].addr_code != (addr & (~((1 << 12) - 1) | (1 - 1)))), 0)
                                                               ) {
        res = __ldb_cmmu(addr, mmu_idx);
    } else {
        physaddr = addr + cpu_single_env->tlb_table[mmu_idx][page_index].addend;
        res = ldub_p((uint8_t *)(long)(((uint8_t *)physaddr)));
    }
    return res;
}


static __attribute__ (( always_inline )) __inline__ int ldsb_code(target_ulong ptr)
{
    int res, page_index;
    target_ulong addr;
    unsigned long physaddr;
    int mmu_idx;

    addr = ptr;
    page_index = (addr >> 12) & ((1 << 8) - 1);
    mmu_idx = (cpu_mmu_index(cpu_single_env));
    if (__builtin_expect(!!(cpu_single_env->tlb_table[mmu_idx][page_index].addr_code != (addr & (~((1 << 12) - 1) | (1 - 1)))), 0)
                                                               ) {
        res = (int8_t)__ldb_cmmu(addr, mmu_idx);
    } else {
        physaddr = addr + cpu_single_env->tlb_table[mmu_idx][page_index].addend;
        res = ldsb_p((uint8_t *)(long)(((uint8_t *)physaddr)));
    }
    return res;
}
# 289 "../../exec-all.h" 2


# 1 "../../softmmu_header.h" 1
# 74 "../../softmmu_header.h"
static __attribute__ (( always_inline )) __inline__ uint32_t lduw_code(target_ulong ptr)
{
    int page_index;
    uint32_t res;
    target_ulong addr;
    unsigned long physaddr;
    int mmu_idx;

    addr = ptr;
    page_index = (addr >> 12) & ((1 << 8) - 1);
    mmu_idx = (cpu_mmu_index(cpu_single_env));
    if (__builtin_expect(!!(cpu_single_env->tlb_table[mmu_idx][page_index].addr_code != (addr & (~((1 << 12) - 1) | (2 - 1)))), 0)
                                                               ) {
        res = __ldw_cmmu(addr, mmu_idx);
    } else {
        physaddr = addr + cpu_single_env->tlb_table[mmu_idx][page_index].addend;
        res = lduw_le_p((uint8_t *)(long)(((uint8_t *)physaddr)));
    }
    return res;
}


static __attribute__ (( always_inline )) __inline__ int ldsw_code(target_ulong ptr)
{
    int res, page_index;
    target_ulong addr;
    unsigned long physaddr;
    int mmu_idx;

    addr = ptr;
    page_index = (addr >> 12) & ((1 << 8) - 1);
    mmu_idx = (cpu_mmu_index(cpu_single_env));
    if (__builtin_expect(!!(cpu_single_env->tlb_table[mmu_idx][page_index].addr_code != (addr & (~((1 << 12) - 1) | (2 - 1)))), 0)
                                                               ) {
        res = (int16_t)__ldw_cmmu(addr, mmu_idx);
    } else {
        physaddr = addr + cpu_single_env->tlb_table[mmu_idx][page_index].addend;
        res = ldsw_le_p((uint8_t *)(long)(((uint8_t *)physaddr)));
    }
    return res;
}
# 292 "../../exec-all.h" 2


# 1 "../../softmmu_header.h" 1
# 74 "../../softmmu_header.h"
static __attribute__ (( always_inline )) __inline__ uint32_t ldl_code(target_ulong ptr)
{
    int page_index;
    uint32_t res;
    target_ulong addr;
    unsigned long physaddr;
    int mmu_idx;

    addr = ptr;
    page_index = (addr >> 12) & ((1 << 8) - 1);
    mmu_idx = (cpu_mmu_index(cpu_single_env));
    if (__builtin_expect(!!(cpu_single_env->tlb_table[mmu_idx][page_index].addr_code != (addr & (~((1 << 12) - 1) | (4 - 1)))), 0)
                                                               ) {
        res = __ldl_cmmu(addr, mmu_idx);
    } else {
        physaddr = addr + cpu_single_env->tlb_table[mmu_idx][page_index].addend;
        res = ldl_le_p((uint8_t *)(long)(((uint8_t *)physaddr)));
    }
    return res;
}
# 295 "../../exec-all.h" 2


# 1 "../../softmmu_header.h" 1
# 74 "../../softmmu_header.h"
static __attribute__ (( always_inline )) __inline__ uint64_t ldq_code(target_ulong ptr)
{
    int page_index;
    uint64_t res;
    target_ulong addr;
    unsigned long physaddr;
    int mmu_idx;

    addr = ptr;
    page_index = (addr >> 12) & ((1 << 8) - 1);
    mmu_idx = (cpu_mmu_index(cpu_single_env));
    if (__builtin_expect(!!(cpu_single_env->tlb_table[mmu_idx][page_index].addr_code != (addr & (~((1 << 12) - 1) | (8 - 1)))), 0)
                                                               ) {
        res = __ldq_cmmu(addr, mmu_idx);
    } else {
        physaddr = addr + cpu_single_env->tlb_table[mmu_idx][page_index].addend;
        res = ldq_le_p((uint8_t *)(long)(((uint8_t *)physaddr)));
    }
    return res;
}
# 298 "../../exec-all.h" 2
# 314 "../../exec-all.h"
static __attribute__ (( always_inline )) __inline__ tb_page_addr_t get_page_addr_code(struct CPUX86State *env1, target_ulong addr)
{
    int mmu_idx, page_index, pd;
    void *p;

    page_index = (addr >> 12) & ((1 << 8) - 1);
    mmu_idx = cpu_mmu_index(env1);
    if (__builtin_expect(!!(env1->tlb_table[mmu_idx][page_index].addr_code != (addr & ~((1 << 12) - 1))), 0)
                                           ) {
        ldub_code(addr);
    }
    pd = env1->tlb_table[mmu_idx][page_index].addr_code & ~~((1 << 12) - 1);
    if (pd > (1 << 3) && !(pd & (1))) {



        cpu_abort(env1, "Trying to execute code outside RAM or ROM at 0x" "%016" "ll" "x" "\n", addr);

    }
    p = (void *)(unsigned long)addr
        + env1->tlb_table[mmu_idx][page_index].addend;
    return qemu_ram_addr_from_host_nofail(p);
}


typedef void (CPUDebugExcpHandler)(struct CPUX86State *env);

CPUDebugExcpHandler *cpu_set_debug_excp_handler(CPUDebugExcpHandler *handler);


extern int singlestep;


extern volatile sig_atomic_t exit_request;
# 28 "../../target-i386/translate.c" 2
# 1 "../../disas.h" 1







void disas(FILE *out, void *code, unsigned long size);
void target_disas(FILE *out, target_ulong code, target_ulong size, int flags);

void monitor_disas(Monitor *mon, struct CPUX86State *env,
                   target_ulong pc, int nb_insn, int is_physical, int flags);


const char *lookup_symbol(target_ulong orig_addr);


struct syminfo;
struct elf32_sym;
struct elf64_sym;




typedef const char *(*lookup_symbol_t)(struct syminfo *s, target_phys_addr_t orig_addr);


struct syminfo {
    lookup_symbol_t lookup_symbol;
    unsigned int disas_num_syms;
    union {
      struct elf32_sym *elf32;
      struct elf64_sym *elf64;
    } disas_symtab;
    const char *disas_strtab;
    struct syminfo *next;
};


extern struct syminfo *syminfos;
# 29 "../../target-i386/translate.c" 2
# 1 "../../tcg/tcg-op.h" 1
# 24 "../../tcg/tcg-op.h"
# 1 "../../tcg/tcg.h" 1
# 25 "../../tcg/tcg.h"
# 1 "../../tcg/arm/tcg-target.h" 1
# 31 "../../tcg/arm/tcg-target.h"
enum {
    TCG_REG_R0 = 0,
    TCG_REG_R1,
    TCG_REG_R2,
    TCG_REG_R3,
    TCG_REG_R4,
    TCG_REG_R5,
    TCG_REG_R6,
    TCG_REG_R7,
    TCG_REG_R8,
    TCG_REG_R9,
    TCG_REG_R10,
    TCG_REG_R11,
    TCG_REG_R12,
    TCG_REG_R13,
    TCG_REG_R14,
    TCG_REG_PC,
};
# 78 "../../tcg/arm/tcg-target.h"
enum {

    TCG_AREG0 = TCG_REG_R7,
};

static __attribute__ (( always_inline )) __inline__ void flush_icache_range(unsigned long start, unsigned long stop)
{

    __builtin___clear_cache((char *) start, (char *) stop);






}
# 26 "../../tcg/tcg.h" 2
# 1 "../../tcg/tcg-runtime.h" 1




int32_t tcg_helper_div_i32(int32_t arg1, int32_t arg2);
int32_t tcg_helper_rem_i32(int32_t arg1, int32_t arg2);
uint32_t tcg_helper_divu_i32(uint32_t arg1, uint32_t arg2);
uint32_t tcg_helper_remu_i32(uint32_t arg1, uint32_t arg2);

int64_t tcg_helper_shl_i64(int64_t arg1, int64_t arg2);
int64_t tcg_helper_shr_i64(int64_t arg1, int64_t arg2);
int64_t tcg_helper_sar_i64(int64_t arg1, int64_t arg2);
int64_t tcg_helper_div_i64(int64_t arg1, int64_t arg2);
int64_t tcg_helper_rem_i64(int64_t arg1, int64_t arg2);
uint64_t tcg_helper_divu_i64(uint64_t arg1, uint64_t arg2);
uint64_t tcg_helper_remu_i64(uint64_t arg1, uint64_t arg2);
# 27 "../../tcg/tcg.h" 2


typedef int32_t tcg_target_long;
typedef uint32_t tcg_target_ulong;
# 43 "../../tcg/tcg.h"
typedef uint32_t TCGRegSet;






typedef enum TCGOpcode {

# 1 "../../tcg/tcg-opc.h" 1
# 30 "../../tcg/tcg-opc.h"
INDEX_op_end,
INDEX_op_nop,
INDEX_op_nop1,
INDEX_op_nop2,
INDEX_op_nop3,
INDEX_op_nopn,

INDEX_op_discard,

INDEX_op_set_label,
INDEX_op_call,
INDEX_op_jmp,
INDEX_op_br,

INDEX_op_mov_i32,
INDEX_op_movi_i32,
INDEX_op_setcond_i32,

INDEX_op_ld8u_i32,
INDEX_op_ld8s_i32,
INDEX_op_ld16u_i32,
INDEX_op_ld16s_i32,
INDEX_op_ld_i32,
INDEX_op_st8_i32,
INDEX_op_st16_i32,
INDEX_op_st_i32,

INDEX_op_add_i32,
INDEX_op_sub_i32,
INDEX_op_mul_i32,
# 70 "../../tcg/tcg-opc.h"
INDEX_op_and_i32,
INDEX_op_or_i32,
INDEX_op_xor_i32,

INDEX_op_shl_i32,
INDEX_op_shr_i32,
INDEX_op_sar_i32,

INDEX_op_rotl_i32,
INDEX_op_rotr_i32,





INDEX_op_brcond_i32,

INDEX_op_add2_i32,
INDEX_op_sub2_i32,
INDEX_op_brcond2_i32,
INDEX_op_mulu2_i32,
INDEX_op_setcond2_i32,


INDEX_op_ext8s_i32,


INDEX_op_ext16s_i32,





INDEX_op_ext16u_i32,


INDEX_op_bswap16_i32,


INDEX_op_bswap32_i32,


INDEX_op_not_i32,


INDEX_op_neg_i32,


INDEX_op_andc_i32,
# 231 "../../tcg/tcg-opc.h"
INDEX_op_debug_insn_start,



INDEX_op_exit_tb,
INDEX_op_goto_tb,






INDEX_op_qemu_ld8u,




INDEX_op_qemu_ld8s,




INDEX_op_qemu_ld16u,




INDEX_op_qemu_ld16s,




INDEX_op_qemu_ld32,




INDEX_op_qemu_ld64,





INDEX_op_qemu_st8,




INDEX_op_qemu_st16,




INDEX_op_qemu_st32,




INDEX_op_qemu_st64,
# 53 "../../tcg/tcg.h" 2

    NB_OPS,
} TCGOpcode;
# 68 "../../tcg/tcg.h"
typedef struct TCGRelocation {
    struct TCGRelocation *next;
    int type;
    uint8_t *ptr;
    tcg_target_long addend;
} TCGRelocation;

typedef struct TCGLabel {
    int has_value;
    union {
        tcg_target_ulong value;
        TCGRelocation *first_reloc;
    } u;
} TCGLabel;

typedef struct TCGPool {
    struct TCGPool *next;
    int size;
    uint8_t data[0] __attribute__ ((aligned));
} TCGPool;
# 99 "../../tcg/tcg.h"
typedef enum TCGType {
    TCG_TYPE_I32,
    TCG_TYPE_I64,
    TCG_TYPE_COUNT,



    TCG_TYPE_REG = TCG_TYPE_I32,






    TCG_TYPE_PTR = TCG_TYPE_REG,



    TCG_TYPE_TL = TCG_TYPE_I64,



} TCGType;

typedef tcg_target_ulong TCGArg;
# 166 "../../tcg/tcg.h"
typedef int TCGv_i32;
typedef int TCGv_i64;
# 206 "../../tcg/tcg.h"
typedef enum {
    TCG_COND_EQ,
    TCG_COND_NE,
    TCG_COND_LT,
    TCG_COND_GE,
    TCG_COND_LE,
    TCG_COND_GT,

    TCG_COND_LTU,
    TCG_COND_GEU,
    TCG_COND_LEU,
    TCG_COND_GTU,
} TCGCond;


static __attribute__ (( always_inline )) __inline__ TCGCond tcg_invert_cond(TCGCond c)
{
    return (TCGCond)(c ^ 1);
}


static __attribute__ (( always_inline )) __inline__ TCGCond tcg_swap_cond(TCGCond c)
{
    int mask = (c < TCG_COND_LT ? 0 : c < TCG_COND_LTU ? 7 : 15);
    return (TCGCond)(c ^ mask);
}

static __attribute__ (( always_inline )) __inline__ TCGCond tcg_unsigned_cond(TCGCond c)
{
    return (c >= TCG_COND_LT && c <= TCG_COND_GT ? c + 4 : c);
}







typedef struct TCGTemp {
    TCGType base_type;
    TCGType type;
    int val_type;
    int reg;
    tcg_target_long val;
    int mem_reg;
    tcg_target_long mem_offset;
    unsigned int fixed_reg:1;
    unsigned int mem_coherent:1;
    unsigned int mem_allocated:1;
    unsigned int temp_local:1;


    unsigned int temp_allocated:1;

    int next_free_temp;
    const char *name;
} TCGTemp;

typedef struct TCGHelperInfo {
    tcg_target_ulong func;
    const char *name;
} TCGHelperInfo;

typedef struct TCGContext TCGContext;

struct TCGContext {
    uint8_t *pool_cur, *pool_end;
    TCGPool *pool_first, *pool_current;
    TCGLabel *labels;
    int nb_labels;
    TCGTemp *temps;
    int nb_globals;
    int nb_temps;

    int first_free_temp[TCG_TYPE_COUNT * 2];


    uint8_t *code_buf;
    unsigned long *tb_next;
    uint16_t *tb_next_offset;
    uint16_t *tb_jmp_offset;


    uint16_t *op_dead_iargs;




    int reg_to_temp[16];
    TCGRegSet reserved_regs;
    tcg_target_long current_frame_offset;
    tcg_target_long frame_start;
    tcg_target_long frame_end;
    int frame_reg;

    uint8_t *code_ptr;
    TCGTemp static_temps[512];

    TCGHelperInfo *helpers;
    int nb_helpers;
    int allocated_helpers;
    int helpers_sorted;
# 326 "../../tcg/tcg.h"
};

extern TCGContext tcg_ctx;
extern uint16_t *gen_opc_ptr;
extern TCGArg *gen_opparam_ptr;
extern uint16_t gen_opc_buf[];
extern TCGArg gen_opparam_buf[];



void *tcg_malloc_internal(TCGContext *s, int size);
void tcg_pool_reset(TCGContext *s);
void tcg_pool_delete(TCGContext *s);

static __attribute__ (( always_inline )) __inline__ void *tcg_malloc(int size)
{
    TCGContext *s = &tcg_ctx;
    uint8_t *ptr, *ptr_end;
    size = (size + sizeof(long) - 1) & ~(sizeof(long) - 1);
    ptr = s->pool_cur;
    ptr_end = ptr + size;
    if (__builtin_expect(!!(ptr_end > s->pool_end), 0)) {
        return tcg_malloc_internal(&tcg_ctx, size);
    } else {
        s->pool_cur = ptr_end;
        return ptr;
    }
}

void tcg_context_init(TCGContext *s);
void tcg_prologue_init(TCGContext *s);
void tcg_func_start(TCGContext *s);

int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf);
int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset);

void tcg_set_frame(TCGContext *s, int reg,
                   tcg_target_long start, tcg_target_long size);

TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name);
TCGv_i32 tcg_global_mem_new_i32(int reg, tcg_target_long offset,
                                const char *name);
TCGv_i32 tcg_temp_new_internal_i32(int temp_local);
static __attribute__ (( always_inline )) __inline__ TCGv_i32 tcg_temp_new_i32(void)
{
    return tcg_temp_new_internal_i32(0);
}
static __attribute__ (( always_inline )) __inline__ TCGv_i32 tcg_temp_local_new_i32(void)
{
    return tcg_temp_new_internal_i32(1);
}
void tcg_temp_free_i32(TCGv_i32 arg);
char *tcg_get_arg_str_i32(TCGContext *s, char *buf, int buf_size, TCGv_i32 arg);

TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name);
TCGv_i64 tcg_global_mem_new_i64(int reg, tcg_target_long offset,
                                const char *name);
TCGv_i64 tcg_temp_new_internal_i64(int temp_local);
static __attribute__ (( always_inline )) __inline__ TCGv_i64 tcg_temp_new_i64(void)
{
    return tcg_temp_new_internal_i64(0);
}
static __attribute__ (( always_inline )) __inline__ TCGv_i64 tcg_temp_local_new_i64(void)
{
    return tcg_temp_new_internal_i64(1);
}
void tcg_temp_free_i64(TCGv_i64 arg);
char *tcg_get_arg_str_i64(TCGContext *s, char *buf, int buf_size, TCGv_i64 arg);

void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf);






typedef struct TCGArgConstraint {
    uint16_t ct;
    uint8_t alias_index;
    union {
        TCGRegSet regs;
    } u;
} TCGArgConstraint;
# 420 "../../tcg/tcg.h"
typedef struct TCGOpDef {
    const char *name;
    uint8_t nb_oargs, nb_iargs, nb_cargs, nb_args;
    uint8_t flags;
    TCGArgConstraint *args_ct;
    int *sorted_args;



} TCGOpDef;

typedef struct TCGTargetOpDef {
    TCGOpcode op;
    const char *args_ct_str[16];
} TCGTargetOpDef;







void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs);
# 466 "../../tcg/tcg.h"
void tcg_gen_callN(TCGContext *s, TCGv_i32 func, unsigned int flags,
                   int sizemask, TCGArg ret, int nargs, TCGArg *args);

void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1,
                        int c, int right, int arith);


void tcg_register_helper(void *func, const char *name);
const char *tcg_helper_get_name(TCGContext *s, void *func);
void tcg_dump_ops(TCGContext *s, FILE *outfile);

void dump_ops(const uint16_t *opc_buf, const TCGArg *opparam_buf);
TCGv_i32 tcg_const_i32(int32_t val);
TCGv_i64 tcg_const_i64(int64_t val);
TCGv_i32 tcg_const_local_i32(int32_t val);
TCGv_i64 tcg_const_local_i64(int64_t val);

extern uint8_t code_gen_prologue[];
# 25 "../../tcg/tcg-op.h" 2

int gen_new_label(void);

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op1_i32(TCGOpcode opc, TCGv_i32 arg1)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op1_i64(TCGOpcode opc, TCGv_i64 arg1)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op1i(TCGOpcode opc, TCGArg arg1)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = arg1;
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op2_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op2_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op2i_i32(TCGOpcode opc, TCGv_i32 arg1, TCGArg arg2)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = arg2;
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op2i_i64(TCGOpcode opc, TCGv_i64 arg1, TCGArg arg2)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = arg2;
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op2ii(TCGOpcode opc, TCGArg arg1, TCGArg arg2)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = arg1;
    *gen_opparam_ptr++ = arg2;
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op3_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
                                   TCGv_i32 arg3)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
    *gen_opparam_ptr++ = (arg3);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op3_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
                                   TCGv_i64 arg3)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
    *gen_opparam_ptr++ = (arg3);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op3i_i32(TCGOpcode opc, TCGv_i32 arg1,
                                    TCGv_i32 arg2, TCGArg arg3)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
    *gen_opparam_ptr++ = arg3;
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op3i_i64(TCGOpcode opc, TCGv_i64 arg1,
                                    TCGv_i64 arg2, TCGArg arg3)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
    *gen_opparam_ptr++ = arg3;
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ldst_op_i32(TCGOpcode opc, TCGv_i32 val,
                                       TCGv_i32 base, TCGArg offset)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (val);
    *gen_opparam_ptr++ = (base);
    *gen_opparam_ptr++ = offset;
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ldst_op_i64(TCGOpcode opc, TCGv_i64 val,
                                       TCGv_i32 base, TCGArg offset)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (val);
    *gen_opparam_ptr++ = (base);
    *gen_opparam_ptr++ = offset;
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_qemu_ldst_op_i64_i32(TCGOpcode opc, TCGv_i64 val,
                                                TCGv_i32 addr, TCGArg mem_index)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (val);
    *gen_opparam_ptr++ = (addr);
    *gen_opparam_ptr++ = mem_index;
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_qemu_ldst_op_i64_i64(TCGOpcode opc, TCGv_i64 val,
                                                TCGv_i64 addr, TCGArg mem_index)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (val);
    *gen_opparam_ptr++ = (addr);
    *gen_opparam_ptr++ = mem_index;
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op4_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
                                   TCGv_i32 arg3, TCGv_i32 arg4)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
    *gen_opparam_ptr++ = (arg3);
    *gen_opparam_ptr++ = (arg4);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op4_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
                                   TCGv_i64 arg3, TCGv_i64 arg4)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
    *gen_opparam_ptr++ = (arg3);
    *gen_opparam_ptr++ = (arg4);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op4i_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
                                    TCGv_i32 arg3, TCGArg arg4)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
    *gen_opparam_ptr++ = (arg3);
    *gen_opparam_ptr++ = arg4;
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op4i_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
                                    TCGv_i64 arg3, TCGArg arg4)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
    *gen_opparam_ptr++ = (arg3);
    *gen_opparam_ptr++ = arg4;
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op4ii_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
                                     TCGArg arg3, TCGArg arg4)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
    *gen_opparam_ptr++ = arg3;
    *gen_opparam_ptr++ = arg4;
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op4ii_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
                                     TCGArg arg3, TCGArg arg4)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
    *gen_opparam_ptr++ = arg3;
    *gen_opparam_ptr++ = arg4;
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op5_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
                                   TCGv_i32 arg3, TCGv_i32 arg4, TCGv_i32 arg5)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
    *gen_opparam_ptr++ = (arg3);
    *gen_opparam_ptr++ = (arg4);
    *gen_opparam_ptr++ = (arg5);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op5_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
                                   TCGv_i64 arg3, TCGv_i64 arg4, TCGv_i64 arg5)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
    *gen_opparam_ptr++ = (arg3);
    *gen_opparam_ptr++ = (arg4);
    *gen_opparam_ptr++ = (arg5);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op5i_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
                                    TCGv_i32 arg3, TCGv_i32 arg4, TCGArg arg5)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
    *gen_opparam_ptr++ = (arg3);
    *gen_opparam_ptr++ = (arg4);
    *gen_opparam_ptr++ = arg5;
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op5i_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
                                    TCGv_i64 arg3, TCGv_i64 arg4, TCGArg arg5)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
    *gen_opparam_ptr++ = (arg3);
    *gen_opparam_ptr++ = (arg4);
    *gen_opparam_ptr++ = arg5;
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op5ii_i32(TCGOpcode opc, TCGv_i32 arg1,
                                     TCGv_i32 arg2, TCGv_i32 arg3,
                                     TCGArg arg4, TCGArg arg5)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
    *gen_opparam_ptr++ = (arg3);
    *gen_opparam_ptr++ = arg4;
    *gen_opparam_ptr++ = arg5;
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op5ii_i64(TCGOpcode opc, TCGv_i64 arg1,
                                     TCGv_i64 arg2, TCGv_i64 arg3,
                                     TCGArg arg4, TCGArg arg5)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
    *gen_opparam_ptr++ = (arg3);
    *gen_opparam_ptr++ = arg4;
    *gen_opparam_ptr++ = arg5;
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op6_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
                                   TCGv_i32 arg3, TCGv_i32 arg4, TCGv_i32 arg5,
                                   TCGv_i32 arg6)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
    *gen_opparam_ptr++ = (arg3);
    *gen_opparam_ptr++ = (arg4);
    *gen_opparam_ptr++ = (arg5);
    *gen_opparam_ptr++ = (arg6);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op6_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
                                   TCGv_i64 arg3, TCGv_i64 arg4, TCGv_i64 arg5,
                                   TCGv_i64 arg6)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
    *gen_opparam_ptr++ = (arg3);
    *gen_opparam_ptr++ = (arg4);
    *gen_opparam_ptr++ = (arg5);
    *gen_opparam_ptr++ = (arg6);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op6i_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
                                    TCGv_i32 arg3, TCGv_i32 arg4,
                                    TCGv_i32 arg5, TCGArg arg6)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
    *gen_opparam_ptr++ = (arg3);
    *gen_opparam_ptr++ = (arg4);
    *gen_opparam_ptr++ = (arg5);
    *gen_opparam_ptr++ = arg6;
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op6i_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
                                    TCGv_i64 arg3, TCGv_i64 arg4,
                                    TCGv_i64 arg5, TCGArg arg6)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
    *gen_opparam_ptr++ = (arg3);
    *gen_opparam_ptr++ = (arg4);
    *gen_opparam_ptr++ = (arg5);
    *gen_opparam_ptr++ = arg6;
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op6ii_i32(TCGOpcode opc, TCGv_i32 arg1,
                                     TCGv_i32 arg2, TCGv_i32 arg3,
                                     TCGv_i32 arg4, TCGArg arg5, TCGArg arg6)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
    *gen_opparam_ptr++ = (arg3);
    *gen_opparam_ptr++ = (arg4);
    *gen_opparam_ptr++ = arg5;
    *gen_opparam_ptr++ = arg6;
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_op6ii_i64(TCGOpcode opc, TCGv_i64 arg1,
                                     TCGv_i64 arg2, TCGv_i64 arg3,
                                     TCGv_i64 arg4, TCGArg arg5, TCGArg arg6)
{
    *gen_opc_ptr++ = opc;
    *gen_opparam_ptr++ = (arg1);
    *gen_opparam_ptr++ = (arg2);
    *gen_opparam_ptr++ = (arg3);
    *gen_opparam_ptr++ = (arg4);
    *gen_opparam_ptr++ = arg5;
    *gen_opparam_ptr++ = arg6;
}

static __attribute__ (( always_inline )) __inline__ void gen_set_label(int n)
{
    tcg_gen_op1i(INDEX_op_set_label, n);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_br(int label)
{
    tcg_gen_op1i(INDEX_op_br, label);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_mov_i32(TCGv_i32 ret, TCGv_i32 arg)
{
    if (!((ret) == (arg)))
        tcg_gen_op2_i32(INDEX_op_mov_i32, ret, arg);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_movi_i32(TCGv_i32 ret, int32_t arg)
{
    tcg_gen_op2i_i32(INDEX_op_movi_i32, ret, arg);
}



static __attribute__ (( always_inline )) __inline__ int tcg_gen_sizemask(int n, int is_64bit, int is_signed)
{
    return (is_64bit << n*2) | (is_signed << (n*2 + 1));
}


static __attribute__ (( always_inline )) __inline__ void tcg_gen_helperN(void *func, int flags, int sizemask,
                                   TCGArg ret, int nargs, TCGArg *args)
{
    TCGv_i32 fn;
    fn = tcg_const_i32((tcg_target_long)func);
    tcg_gen_callN(&tcg_ctx, fn, flags, sizemask, ret,
                  nargs, args);
    tcg_temp_free_i32(fn);
}






static __attribute__ (( always_inline )) __inline__ void tcg_gen_helper32(void *func, int sizemask, TCGv_i32 ret,
                                    TCGv_i32 a, TCGv_i32 b)
{
    TCGv_i32 fn;
    TCGArg args[2];
    fn = tcg_const_i32((tcg_target_long)func);
    args[0] = (a);
    args[1] = (b);
    tcg_gen_callN(&tcg_ctx, fn, 0x0020 | 0x0010, sizemask,
                  (ret), 2, args);
    tcg_temp_free_i32(fn);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_helper64(void *func, int sizemask, TCGv_i64 ret,
                                    TCGv_i64 a, TCGv_i64 b)
{
    TCGv_i32 fn;
    TCGArg args[2];
    fn = tcg_const_i32((tcg_target_long)func);
    args[0] = (a);
    args[1] = (b);
    tcg_gen_callN(&tcg_ctx, fn, 0x0020 | 0x0010, sizemask,
                  (ret), 2, args);
    tcg_temp_free_i32(fn);
}



static __attribute__ (( always_inline )) __inline__ void tcg_gen_ld8u_i32(TCGv_i32 ret, TCGv_i32 arg2, tcg_target_long offset)
{
    tcg_gen_ldst_op_i32(INDEX_op_ld8u_i32, ret, arg2, offset);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ld8s_i32(TCGv_i32 ret, TCGv_i32 arg2, tcg_target_long offset)
{
    tcg_gen_ldst_op_i32(INDEX_op_ld8s_i32, ret, arg2, offset);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ld16u_i32(TCGv_i32 ret, TCGv_i32 arg2, tcg_target_long offset)
{
    tcg_gen_ldst_op_i32(INDEX_op_ld16u_i32, ret, arg2, offset);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ld16s_i32(TCGv_i32 ret, TCGv_i32 arg2, tcg_target_long offset)
{
    tcg_gen_ldst_op_i32(INDEX_op_ld16s_i32, ret, arg2, offset);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ld_i32(TCGv_i32 ret, TCGv_i32 arg2, tcg_target_long offset)
{
    tcg_gen_ldst_op_i32(INDEX_op_ld_i32, ret, arg2, offset);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_st8_i32(TCGv_i32 arg1, TCGv_i32 arg2, tcg_target_long offset)
{
    tcg_gen_ldst_op_i32(INDEX_op_st8_i32, arg1, arg2, offset);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_st16_i32(TCGv_i32 arg1, TCGv_i32 arg2, tcg_target_long offset)
{
    tcg_gen_ldst_op_i32(INDEX_op_st16_i32, arg1, arg2, offset);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_st_i32(TCGv_i32 arg1, TCGv_i32 arg2, tcg_target_long offset)
{
    tcg_gen_ldst_op_i32(INDEX_op_st_i32, arg1, arg2, offset);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_add_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
{
    tcg_gen_op3_i32(INDEX_op_add_i32, ret, arg1, arg2);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_addi_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
{

    if (arg2 == 0) {
        tcg_gen_mov_i32(ret, arg1);
    } else {
        TCGv_i32 t0 = tcg_const_i32(arg2);
        tcg_gen_add_i32(ret, arg1, t0);
        tcg_temp_free_i32(t0);
    }
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_sub_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
{
    tcg_gen_op3_i32(INDEX_op_sub_i32, ret, arg1, arg2);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_subfi_i32(TCGv_i32 ret, int32_t arg1, TCGv_i32 arg2)
{
    TCGv_i32 t0 = tcg_const_i32(arg1);
    tcg_gen_sub_i32(ret, t0, arg2);
    tcg_temp_free_i32(t0);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_subi_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
{

    if (arg2 == 0) {
        tcg_gen_mov_i32(ret, arg1);
    } else {
        TCGv_i32 t0 = tcg_const_i32(arg2);
        tcg_gen_sub_i32(ret, arg1, t0);
        tcg_temp_free_i32(t0);
    }
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_and_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
{
    if (((arg1) == (arg2))) {
        tcg_gen_mov_i32(ret, arg1);
    } else {
        tcg_gen_op3_i32(INDEX_op_and_i32, ret, arg1, arg2);
    }
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_andi_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
{

    if (arg2 == 0) {
        tcg_gen_movi_i32(ret, 0);
    } else if (arg2 == 0xffffffff) {
        tcg_gen_mov_i32(ret, arg1);
    } else {
        TCGv_i32 t0 = tcg_const_i32(arg2);
        tcg_gen_and_i32(ret, arg1, t0);
        tcg_temp_free_i32(t0);
    }
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_or_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
{
    if (((arg1) == (arg2))) {
        tcg_gen_mov_i32(ret, arg1);
    } else {
        tcg_gen_op3_i32(INDEX_op_or_i32, ret, arg1, arg2);
    }
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ori_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
{

    if (arg2 == 0xffffffff) {
        tcg_gen_movi_i32(ret, 0xffffffff);
    } else if (arg2 == 0) {
        tcg_gen_mov_i32(ret, arg1);
    } else {
        TCGv_i32 t0 = tcg_const_i32(arg2);
        tcg_gen_or_i32(ret, arg1, t0);
        tcg_temp_free_i32(t0);
    }
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_xor_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
{
    if (((arg1) == (arg2))) {
        tcg_gen_movi_i32(ret, 0);
    } else {
        tcg_gen_op3_i32(INDEX_op_xor_i32, ret, arg1, arg2);
    }
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_xori_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
{

    if (arg2 == 0) {
        tcg_gen_mov_i32(ret, arg1);
    } else {
        TCGv_i32 t0 = tcg_const_i32(arg2);
        tcg_gen_xor_i32(ret, arg1, t0);
        tcg_temp_free_i32(t0);
    }
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_shl_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
{
    tcg_gen_op3_i32(INDEX_op_shl_i32, ret, arg1, arg2);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_shli_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
{
    if (arg2 == 0) {
        tcg_gen_mov_i32(ret, arg1);
    } else {
        TCGv_i32 t0 = tcg_const_i32(arg2);
        tcg_gen_shl_i32(ret, arg1, t0);
        tcg_temp_free_i32(t0);
    }
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_shr_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
{
    tcg_gen_op3_i32(INDEX_op_shr_i32, ret, arg1, arg2);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_shri_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
{
    if (arg2 == 0) {
        tcg_gen_mov_i32(ret, arg1);
    } else {
        TCGv_i32 t0 = tcg_const_i32(arg2);
        tcg_gen_shr_i32(ret, arg1, t0);
        tcg_temp_free_i32(t0);
    }
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_sar_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
{
    tcg_gen_op3_i32(INDEX_op_sar_i32, ret, arg1, arg2);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_sari_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
{
    if (arg2 == 0) {
        tcg_gen_mov_i32(ret, arg1);
    } else {
        TCGv_i32 t0 = tcg_const_i32(arg2);
        tcg_gen_sar_i32(ret, arg1, t0);
        tcg_temp_free_i32(t0);
    }
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_brcond_i32(TCGCond cond, TCGv_i32 arg1,
                                      TCGv_i32 arg2, int label_index)
{
    tcg_gen_op4ii_i32(INDEX_op_brcond_i32, arg1, arg2, cond, label_index);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_brcondi_i32(TCGCond cond, TCGv_i32 arg1,
                                       int32_t arg2, int label_index)
{
    TCGv_i32 t0 = tcg_const_i32(arg2);
    tcg_gen_brcond_i32(cond, arg1, t0, label_index);
    tcg_temp_free_i32(t0);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_setcond_i32(TCGCond cond, TCGv_i32 ret,
                                       TCGv_i32 arg1, TCGv_i32 arg2)
{
    tcg_gen_op4i_i32(INDEX_op_setcond_i32, ret, arg1, arg2, cond);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_setcondi_i32(TCGCond cond, TCGv_i32 ret,
                                        TCGv_i32 arg1, int32_t arg2)
{
    TCGv_i32 t0 = tcg_const_i32(arg2);
    tcg_gen_setcond_i32(cond, ret, arg1, t0);
    tcg_temp_free_i32(t0);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_mul_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
{
    tcg_gen_op3_i32(INDEX_op_mul_i32, ret, arg1, arg2);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_muli_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
{
    TCGv_i32 t0 = tcg_const_i32(arg2);
    tcg_gen_mul_i32(ret, arg1, t0);
    tcg_temp_free_i32(t0);
}
# 724 "../../tcg/tcg-op.h"
static __attribute__ (( always_inline )) __inline__ void tcg_gen_div_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
{
    int sizemask = 0;

    sizemask |= tcg_gen_sizemask(0, 0, 1);
    sizemask |= tcg_gen_sizemask(1, 0, 1);
    sizemask |= tcg_gen_sizemask(2, 0, 1);

    tcg_gen_helper32(tcg_helper_div_i32, sizemask, ret, arg1, arg2);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_rem_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
{
    int sizemask = 0;

    sizemask |= tcg_gen_sizemask(0, 0, 1);
    sizemask |= tcg_gen_sizemask(1, 0, 1);
    sizemask |= tcg_gen_sizemask(2, 0, 1);

    tcg_gen_helper32(tcg_helper_rem_i32, sizemask, ret, arg1, arg2);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_divu_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
{
    int sizemask = 0;

    sizemask |= tcg_gen_sizemask(0, 0, 0);
    sizemask |= tcg_gen_sizemask(1, 0, 0);
    sizemask |= tcg_gen_sizemask(2, 0, 0);

    tcg_gen_helper32(tcg_helper_divu_i32, sizemask, ret, arg1, arg2);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_remu_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
{
    int sizemask = 0;

    sizemask |= tcg_gen_sizemask(0, 0, 0);
    sizemask |= tcg_gen_sizemask(1, 0, 0);
    sizemask |= tcg_gen_sizemask(2, 0, 0);

    tcg_gen_helper32(tcg_helper_remu_i32, sizemask, ret, arg1, arg2);
}




static __attribute__ (( always_inline )) __inline__ void tcg_gen_mov_i64(TCGv_i64 ret, TCGv_i64 arg)
{
    if (!((ret) == (arg))) {
        tcg_gen_mov_i32((ret), (arg));
        tcg_gen_mov_i32(((ret) + 1), ((arg) + 1));
    }
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_movi_i64(TCGv_i64 ret, int64_t arg)
{
    tcg_gen_movi_i32((ret), arg);
    tcg_gen_movi_i32(((ret) + 1), arg >> 32);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ld8u_i64(TCGv_i64 ret, TCGv_i32 arg2,
                                    tcg_target_long offset)
{
    tcg_gen_ld8u_i32((ret), arg2, offset);
    tcg_gen_movi_i32(((ret) + 1), 0);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ld8s_i64(TCGv_i64 ret, TCGv_i32 arg2,
                                    tcg_target_long offset)
{
    tcg_gen_ld8s_i32((ret), arg2, offset);
    tcg_gen_sari_i32(((ret) + 1), ((ret) + 1), 31);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ld16u_i64(TCGv_i64 ret, TCGv_i32 arg2,
                                     tcg_target_long offset)
{
    tcg_gen_ld16u_i32((ret), arg2, offset);
    tcg_gen_movi_i32(((ret) + 1), 0);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ld16s_i64(TCGv_i64 ret, TCGv_i32 arg2,
                                     tcg_target_long offset)
{
    tcg_gen_ld16s_i32((ret), arg2, offset);
    tcg_gen_sari_i32(((ret) + 1), (ret), 31);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ld32u_i64(TCGv_i64 ret, TCGv_i32 arg2,
                                     tcg_target_long offset)
{
    tcg_gen_ld_i32((ret), arg2, offset);
    tcg_gen_movi_i32(((ret) + 1), 0);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ld32s_i64(TCGv_i64 ret, TCGv_i32 arg2,
                                     tcg_target_long offset)
{
    tcg_gen_ld_i32((ret), arg2, offset);
    tcg_gen_sari_i32(((ret) + 1), (ret), 31);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ld_i64(TCGv_i64 ret, TCGv_i32 arg2,
                                  tcg_target_long offset)
{






    tcg_gen_ld_i32((ret), arg2, offset);
    tcg_gen_ld_i32(((ret) + 1), arg2, offset + 4);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_st8_i64(TCGv_i64 arg1, TCGv_i32 arg2,
                                   tcg_target_long offset)
{
    tcg_gen_st8_i32((arg1), arg2, offset);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_st16_i64(TCGv_i64 arg1, TCGv_i32 arg2,
                                    tcg_target_long offset)
{
    tcg_gen_st16_i32((arg1), arg2, offset);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_st32_i64(TCGv_i64 arg1, TCGv_i32 arg2,
                                    tcg_target_long offset)
{
    tcg_gen_st_i32((arg1), arg2, offset);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_st_i64(TCGv_i64 arg1, TCGv_i32 arg2,
                                  tcg_target_long offset)
{




    tcg_gen_st_i32((arg1), arg2, offset);
    tcg_gen_st_i32(((arg1) + 1), arg2, offset + 4);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_add_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
{
    tcg_gen_op6_i32(INDEX_op_add2_i32, (ret), ((ret) + 1),
                    (arg1), ((arg1) + 1), (arg2),
                    ((arg2) + 1));
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_sub_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
{
    tcg_gen_op6_i32(INDEX_op_sub2_i32, (ret), ((ret) + 1),
                    (arg1), ((arg1) + 1), (arg2),
                    ((arg2) + 1));
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_and_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
{
    tcg_gen_and_i32((ret), (arg1), (arg2));
    tcg_gen_and_i32(((ret) + 1), ((arg1) + 1), ((arg2) + 1));
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_andi_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
{
    tcg_gen_andi_i32((ret), (arg1), arg2);
    tcg_gen_andi_i32(((ret) + 1), ((arg1) + 1), arg2 >> 32);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_or_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
{
    tcg_gen_or_i32((ret), (arg1), (arg2));
    tcg_gen_or_i32(((ret) + 1), ((arg1) + 1), ((arg2) + 1));
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ori_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
{
    tcg_gen_ori_i32((ret), (arg1), arg2);
    tcg_gen_ori_i32(((ret) + 1), ((arg1) + 1), arg2 >> 32);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_xor_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
{
    tcg_gen_xor_i32((ret), (arg1), (arg2));
    tcg_gen_xor_i32(((ret) + 1), ((arg1) + 1), ((arg2) + 1));
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_xori_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
{
    tcg_gen_xori_i32((ret), (arg1), arg2);
    tcg_gen_xori_i32(((ret) + 1), ((arg1) + 1), arg2 >> 32);
}



static __attribute__ (( always_inline )) __inline__ void tcg_gen_shl_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
{
    int sizemask = 0;

    sizemask |= tcg_gen_sizemask(0, 1, 1);
    sizemask |= tcg_gen_sizemask(1, 1, 1);
    sizemask |= tcg_gen_sizemask(2, 1, 1);

    tcg_gen_helper64(tcg_helper_shl_i64, sizemask, ret, arg1, arg2);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_shli_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
{
    tcg_gen_shifti_i64(ret, arg1, arg2, 0, 0);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_shr_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
{
    int sizemask = 0;

    sizemask |= tcg_gen_sizemask(0, 1, 1);
    sizemask |= tcg_gen_sizemask(1, 1, 1);
    sizemask |= tcg_gen_sizemask(2, 1, 1);

    tcg_gen_helper64(tcg_helper_shr_i64, sizemask, ret, arg1, arg2);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_shri_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
{
    tcg_gen_shifti_i64(ret, arg1, arg2, 1, 0);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_sar_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
{
    int sizemask = 0;

    sizemask |= tcg_gen_sizemask(0, 1, 1);
    sizemask |= tcg_gen_sizemask(1, 1, 1);
    sizemask |= tcg_gen_sizemask(2, 1, 1);

    tcg_gen_helper64(tcg_helper_sar_i64, sizemask, ret, arg1, arg2);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_sari_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
{
    tcg_gen_shifti_i64(ret, arg1, arg2, 1, 1);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_brcond_i64(TCGCond cond, TCGv_i64 arg1,
                                      TCGv_i64 arg2, int label_index)
{
    tcg_gen_op6ii_i32(INDEX_op_brcond2_i32,
                      (arg1), ((arg1) + 1), (arg2),
                      ((arg2) + 1), cond, label_index);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_setcond_i64(TCGCond cond, TCGv_i64 ret,
                                       TCGv_i64 arg1, TCGv_i64 arg2)
{
    tcg_gen_op6i_i32(INDEX_op_setcond2_i32, (ret),
                     (arg1), ((arg1) + 1),
                     (arg2), ((arg2) + 1), cond);
    tcg_gen_movi_i32(((ret) + 1), 0);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_mul_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
{
    TCGv_i64 t0;
    TCGv_i32 t1;

    t0 = tcg_temp_new_i64();
    t1 = tcg_temp_new_i32();

    tcg_gen_op4_i32(INDEX_op_mulu2_i32, (t0), ((t0) + 1),
                    (arg1), (arg2));

    tcg_gen_mul_i32(t1, (arg1), ((arg2) + 1));
    tcg_gen_add_i32(((t0) + 1), ((t0) + 1), t1);
    tcg_gen_mul_i32(t1, ((arg1) + 1), (arg2));
    tcg_gen_add_i32(((t0) + 1), ((t0) + 1), t1);

    tcg_gen_mov_i64(ret, t0);
    tcg_temp_free_i64(t0);
    tcg_temp_free_i32(t1);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_div_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
{
    int sizemask = 0;

    sizemask |= tcg_gen_sizemask(0, 1, 1);
    sizemask |= tcg_gen_sizemask(1, 1, 1);
    sizemask |= tcg_gen_sizemask(2, 1, 1);

    tcg_gen_helper64(tcg_helper_div_i64, sizemask, ret, arg1, arg2);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_rem_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
{
    int sizemask = 0;

    sizemask |= tcg_gen_sizemask(0, 1, 1);
    sizemask |= tcg_gen_sizemask(1, 1, 1);
    sizemask |= tcg_gen_sizemask(2, 1, 1);

    tcg_gen_helper64(tcg_helper_rem_i64, sizemask, ret, arg1, arg2);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_divu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
{
    int sizemask = 0;

    sizemask |= tcg_gen_sizemask(0, 1, 0);
    sizemask |= tcg_gen_sizemask(1, 1, 0);
    sizemask |= tcg_gen_sizemask(2, 1, 0);

    tcg_gen_helper64(tcg_helper_divu_i64, sizemask, ret, arg1, arg2);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_remu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
{
    int sizemask = 0;

    sizemask |= tcg_gen_sizemask(0, 1, 0);
    sizemask |= tcg_gen_sizemask(1, 1, 0);
    sizemask |= tcg_gen_sizemask(2, 1, 0);

    tcg_gen_helper64(tcg_helper_remu_i64, sizemask, ret, arg1, arg2);
}
# 1357 "../../tcg/tcg-op.h"
static __attribute__ (( always_inline )) __inline__ void tcg_gen_addi_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
{

    if (arg2 == 0) {
        tcg_gen_mov_i64(ret, arg1);
    } else {
        TCGv_i64 t0 = tcg_const_i64(arg2);
        tcg_gen_add_i64(ret, arg1, t0);
        tcg_temp_free_i64(t0);
    }
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_subfi_i64(TCGv_i64 ret, int64_t arg1, TCGv_i64 arg2)
{
    TCGv_i64 t0 = tcg_const_i64(arg1);
    tcg_gen_sub_i64(ret, t0, arg2);
    tcg_temp_free_i64(t0);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_subi_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
{

    if (arg2 == 0) {
        tcg_gen_mov_i64(ret, arg1);
    } else {
        TCGv_i64 t0 = tcg_const_i64(arg2);
        tcg_gen_sub_i64(ret, arg1, t0);
        tcg_temp_free_i64(t0);
    }
}
static __attribute__ (( always_inline )) __inline__ void tcg_gen_brcondi_i64(TCGCond cond, TCGv_i64 arg1,
                                       int64_t arg2, int label_index)
{
    TCGv_i64 t0 = tcg_const_i64(arg2);
    tcg_gen_brcond_i64(cond, arg1, t0, label_index);
    tcg_temp_free_i64(t0);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_setcondi_i64(TCGCond cond, TCGv_i64 ret,
                                        TCGv_i64 arg1, int64_t arg2)
{
    TCGv_i64 t0 = tcg_const_i64(arg2);
    tcg_gen_setcond_i64(cond, ret, arg1, t0);
    tcg_temp_free_i64(t0);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_muli_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
{
    TCGv_i64 t0 = tcg_const_i64(arg2);
    tcg_gen_mul_i64(ret, arg1, t0);
    tcg_temp_free_i64(t0);
}





static __attribute__ (( always_inline )) __inline__ void tcg_gen_ext8s_i32(TCGv_i32 ret, TCGv_i32 arg)
{

    tcg_gen_op2_i32(INDEX_op_ext8s_i32, ret, arg);




}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ext16s_i32(TCGv_i32 ret, TCGv_i32 arg)
{

    tcg_gen_op2_i32(INDEX_op_ext16s_i32, ret, arg);




}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ext8u_i32(TCGv_i32 ret, TCGv_i32 arg)
{



    tcg_gen_andi_i32(ret, arg, 0xffu);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ext16u_i32(TCGv_i32 ret, TCGv_i32 arg)
{

    tcg_gen_op2_i32(INDEX_op_ext16u_i32, ret, arg);



}


static __attribute__ (( always_inline )) __inline__ void tcg_gen_bswap16_i32(TCGv_i32 ret, TCGv_i32 arg)
{

    tcg_gen_op2_i32(INDEX_op_bswap16_i32, ret, arg);
# 1466 "../../tcg/tcg-op.h"
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_bswap32_i32(TCGv_i32 ret, TCGv_i32 arg)
{

    tcg_gen_op2_i32(INDEX_op_bswap32_i32, ret, arg);
# 1492 "../../tcg/tcg-op.h"
}


static __attribute__ (( always_inline )) __inline__ void tcg_gen_ext8s_i64(TCGv_i64 ret, TCGv_i64 arg)
{
    tcg_gen_ext8s_i32((ret), (arg));
    tcg_gen_sari_i32(((ret) + 1), (ret), 31);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ext16s_i64(TCGv_i64 ret, TCGv_i64 arg)
{
    tcg_gen_ext16s_i32((ret), (arg));
    tcg_gen_sari_i32(((ret) + 1), (ret), 31);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ext32s_i64(TCGv_i64 ret, TCGv_i64 arg)
{
    tcg_gen_mov_i32((ret), (arg));
    tcg_gen_sari_i32(((ret) + 1), (ret), 31);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ext8u_i64(TCGv_i64 ret, TCGv_i64 arg)
{
    tcg_gen_ext8u_i32((ret), (arg));
    tcg_gen_movi_i32(((ret) + 1), 0);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ext16u_i64(TCGv_i64 ret, TCGv_i64 arg)
{
    tcg_gen_ext16u_i32((ret), (arg));
    tcg_gen_movi_i32(((ret) + 1), 0);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ext32u_i64(TCGv_i64 ret, TCGv_i64 arg)
{
    tcg_gen_mov_i32((ret), (arg));
    tcg_gen_movi_i32(((ret) + 1), 0);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_trunc_i64_i32(TCGv_i32 ret, TCGv_i64 arg)
{
    tcg_gen_mov_i32(ret, (arg));
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_extu_i32_i64(TCGv_i64 ret, TCGv_i32 arg)
{
    tcg_gen_mov_i32((ret), arg);
    tcg_gen_movi_i32(((ret) + 1), 0);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_ext_i32_i64(TCGv_i64 ret, TCGv_i32 arg)
{
    tcg_gen_mov_i32((ret), arg);
    tcg_gen_sari_i32(((ret) + 1), (ret), 31);
}


static __attribute__ (( always_inline )) __inline__ void tcg_gen_bswap16_i64(TCGv_i64 ret, TCGv_i64 arg)
{
    tcg_gen_mov_i32(((ret) + 1), ((arg) + 1));
    tcg_gen_bswap16_i32((ret), (arg));
}


static __attribute__ (( always_inline )) __inline__ void tcg_gen_bswap32_i64(TCGv_i64 ret, TCGv_i64 arg)
{
    tcg_gen_mov_i32(((ret) + 1), ((arg) + 1));
    tcg_gen_bswap32_i32((ret), (arg));
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_bswap64_i64(TCGv_i64 ret, TCGv_i64 arg)
{
    TCGv_i32 t0, t1;
    t0 = tcg_temp_new_i32();
    t1 = tcg_temp_new_i32();

    tcg_gen_bswap32_i32(t0, (arg));
    tcg_gen_bswap32_i32(t1, ((arg) + 1));
    tcg_gen_mov_i32((ret), t1);
    tcg_gen_mov_i32(((ret) + 1), t0);
    tcg_temp_free_i32(t0);
    tcg_temp_free_i32(t1);
}
# 1742 "../../tcg/tcg-op.h"
static __attribute__ (( always_inline )) __inline__ void tcg_gen_neg_i32(TCGv_i32 ret, TCGv_i32 arg)
{

    tcg_gen_op2_i32(INDEX_op_neg_i32, ret, arg);





}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_neg_i64(TCGv_i64 ret, TCGv_i64 arg)
{



    TCGv_i64 t0 = tcg_const_i64(0);
    tcg_gen_sub_i64(ret, t0, arg);
    tcg_temp_free_i64(t0);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_not_i32(TCGv_i32 ret, TCGv_i32 arg)
{

    tcg_gen_op2_i32(INDEX_op_not_i32, ret, arg);



}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_not_i64(TCGv_i64 ret, TCGv_i64 arg)
{



    tcg_gen_not_i32((ret), (arg));
    tcg_gen_not_i32(((ret) + 1), ((arg) + 1));



}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_discard_i32(TCGv_i32 arg)
{
    tcg_gen_op1_i32(INDEX_op_discard, arg);
}


static __attribute__ (( always_inline )) __inline__ void tcg_gen_discard_i64(TCGv_i64 arg)
{
    tcg_gen_discard_i32((arg));
    tcg_gen_discard_i32(((arg) + 1));
}







static __attribute__ (( always_inline )) __inline__ void tcg_gen_concat_i32_i64(TCGv_i64 dest, TCGv_i32 low, TCGv_i32 high)
{

    tcg_gen_mov_i32((dest), low);
    tcg_gen_mov_i32(((dest) + 1), high);
# 1818 "../../tcg/tcg-op.h"
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_concat32_i64(TCGv_i64 dest, TCGv_i64 low, TCGv_i64 high)
{

    tcg_gen_concat_i32_i64(dest, (low), (high));







}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_andc_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
{

    tcg_gen_op3_i32(INDEX_op_andc_i32, ret, arg1, arg2);







}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_andc_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
{



    tcg_gen_andc_i32((ret), (arg1), (arg2));
    tcg_gen_andc_i32(((ret) + 1), ((arg1) + 1), ((arg2) + 1));







}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_eqv_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
{



    tcg_gen_xor_i32(ret, arg1, arg2);
    tcg_gen_not_i32(ret, ret);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_eqv_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
{






    tcg_gen_xor_i64(ret, arg1, arg2);
    tcg_gen_not_i64(ret, ret);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_nand_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
{



    tcg_gen_and_i32(ret, arg1, arg2);
    tcg_gen_not_i32(ret, ret);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_nand_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
{






    tcg_gen_and_i64(ret, arg1, arg2);
    tcg_gen_not_i64(ret, ret);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_nor_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
{



    tcg_gen_or_i32(ret, arg1, arg2);
    tcg_gen_not_i32(ret, ret);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_nor_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
{






    tcg_gen_or_i64(ret, arg1, arg2);
    tcg_gen_not_i64(ret, ret);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_orc_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
{



    TCGv_i32 t0;
    t0 = tcg_temp_new_i32();
    tcg_gen_not_i32(t0, arg2);
    tcg_gen_or_i32(ret, arg1, t0);
    tcg_temp_free_i32(t0);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_orc_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
{






    TCGv_i64 t0;
    t0 = tcg_temp_new_i64();
    tcg_gen_not_i64(t0, arg2);
    tcg_gen_or_i64(ret, arg1, t0);
    tcg_temp_free_i64(t0);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_rotl_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
{

    tcg_gen_op3_i32(INDEX_op_rotl_i32, ret, arg1, arg2);
# 1976 "../../tcg/tcg-op.h"
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_rotl_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
{



    TCGv_i64 t0, t1;

    t0 = tcg_temp_new_i64();
    t1 = tcg_temp_new_i64();
    tcg_gen_shl_i64(t0, arg1, arg2);
    tcg_gen_subfi_i64(t1, 64, arg2);
    tcg_gen_shr_i64(t1, arg1, t1);
    tcg_gen_or_i64(ret, t0, t1);
    tcg_temp_free_i64(t0);
    tcg_temp_free_i64(t1);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_rotli_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
{

    if (arg2 == 0) {
        tcg_gen_mov_i32(ret, arg1);
    } else {

        TCGv_i32 t0 = tcg_const_i32(arg2);
        tcg_gen_rotl_i32(ret, arg1, t0);
        tcg_temp_free_i32(t0);
# 2016 "../../tcg/tcg-op.h"
    }
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_rotli_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
{

    if (arg2 == 0) {
        tcg_gen_mov_i64(ret, arg1);
    } else {





        TCGv_i64 t0, t1;
        t0 = tcg_temp_new_i64();
        t1 = tcg_temp_new_i64();
        tcg_gen_shli_i64(t0, arg1, arg2);
        tcg_gen_shri_i64(t1, arg1, 64 - arg2);
        tcg_gen_or_i64(ret, t0, t1);
        tcg_temp_free_i64(t0);
        tcg_temp_free_i64(t1);

    }
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_rotr_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
{

    tcg_gen_op3_i32(INDEX_op_rotr_i32, ret, arg1, arg2);
# 2058 "../../tcg/tcg-op.h"
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_rotr_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
{



    TCGv_i64 t0, t1;

    t0 = tcg_temp_new_i64();
    t1 = tcg_temp_new_i64();
    tcg_gen_shr_i64(t0, arg1, arg2);
    tcg_gen_subfi_i64(t1, 64, arg2);
    tcg_gen_shl_i64(t1, arg1, t1);
    tcg_gen_or_i64(ret, t0, t1);
    tcg_temp_free_i64(t0);
    tcg_temp_free_i64(t1);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_rotri_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
{

    if (arg2 == 0) {
        tcg_gen_mov_i32(ret, arg1);
    } else {
        tcg_gen_rotli_i32(ret, arg1, 32 - arg2);
    }
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_rotri_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
{

    if (arg2 == 0) {
        tcg_gen_mov_i64(ret, arg1);
    } else {
        tcg_gen_rotli_i64(ret, arg1, 64 - arg2);
    }
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_deposit_i32(TCGv_i32 ret, TCGv_i32 arg1,
           TCGv_i32 arg2, unsigned int ofs,
           unsigned int len)
{



  uint32_t mask = (1u << len) - 1;
  TCGv_i32 t1 = tcg_temp_new_i32 ();

  tcg_gen_andi_i32(t1, arg2, mask);
  tcg_gen_shli_i32(t1, t1, ofs);
  tcg_gen_andi_i32(ret, arg1, ~(mask << ofs));
  tcg_gen_or_i32(ret, ret, t1);

  tcg_temp_free_i32(t1);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_deposit_i64(TCGv_i64 ret, TCGv_i64 arg1,
           TCGv_i64 arg2, unsigned int ofs,
           unsigned int len)
{



  uint64_t mask = (1ull << len) - 1;
  TCGv_i64 t1 = tcg_temp_new_i64 ();

  tcg_gen_andi_i64(t1, arg2, mask);
  tcg_gen_shli_i64(t1, t1, ofs);
  tcg_gen_andi_i64(ret, arg1, ~(mask << ofs));
  tcg_gen_or_i64(ret, ret, t1);

  tcg_temp_free_i64(t1);

}
# 2168 "../../tcg/tcg-op.h"
static __attribute__ (( always_inline )) __inline__ void tcg_gen_debug_insn_start(uint64_t pc)
{


    tcg_gen_op2ii(INDEX_op_debug_insn_start,
                  (uint32_t)(pc), (uint32_t)(pc >> 32));



}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_exit_tb(tcg_target_long val)
{
    tcg_gen_op1i(INDEX_op_exit_tb, val);
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_goto_tb(int idx)
{
    tcg_gen_op1i(INDEX_op_goto_tb, idx);
}


static __attribute__ (( always_inline )) __inline__ void tcg_gen_qemu_ld8u(TCGv_i64 ret, TCGv_i64 addr, int mem_index)
{



    tcg_gen_op4i_i32(INDEX_op_qemu_ld8u, (ret), (addr),
                     ((addr) + 1), mem_index);
    tcg_gen_movi_i32(((ret) + 1), 0);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_qemu_ld8s(TCGv_i64 ret, TCGv_i64 addr, int mem_index)
{



    tcg_gen_op4i_i32(INDEX_op_qemu_ld8s, (ret), (addr),
                     ((addr) + 1), mem_index);
    tcg_gen_sari_i32(((ret) + 1), (ret), 31);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_qemu_ld16u(TCGv_i64 ret, TCGv_i64 addr, int mem_index)
{



    tcg_gen_op4i_i32(INDEX_op_qemu_ld16u, (ret), (addr),
                     ((addr) + 1), mem_index);
    tcg_gen_movi_i32(((ret) + 1), 0);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_qemu_ld16s(TCGv_i64 ret, TCGv_i64 addr, int mem_index)
{



    tcg_gen_op4i_i32(INDEX_op_qemu_ld16s, (ret), (addr),
                     ((addr) + 1), mem_index);
    tcg_gen_sari_i32(((ret) + 1), (ret), 31);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_qemu_ld32u(TCGv_i64 ret, TCGv_i64 addr, int mem_index)
{



    tcg_gen_op4i_i32(INDEX_op_qemu_ld32, (ret), (addr),
                     ((addr) + 1), mem_index);
    tcg_gen_movi_i32(((ret) + 1), 0);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_qemu_ld32s(TCGv_i64 ret, TCGv_i64 addr, int mem_index)
{



    tcg_gen_op4i_i32(INDEX_op_qemu_ld32, (ret), (addr),
                     ((addr) + 1), mem_index);
    tcg_gen_sari_i32(((ret) + 1), (ret), 31);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_qemu_ld64(TCGv_i64 ret, TCGv_i64 addr, int mem_index)
{



    tcg_gen_op5i_i32(INDEX_op_qemu_ld64, (ret), ((ret) + 1),
                     (addr), ((addr) + 1), mem_index);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_qemu_st8(TCGv_i64 arg, TCGv_i64 addr, int mem_index)
{



    tcg_gen_op4i_i32(INDEX_op_qemu_st8, (arg), (addr),
                     ((addr) + 1), mem_index);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_qemu_st16(TCGv_i64 arg, TCGv_i64 addr, int mem_index)
{



    tcg_gen_op4i_i32(INDEX_op_qemu_st16, (arg), (addr),
                     ((addr) + 1), mem_index);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_qemu_st32(TCGv_i64 arg, TCGv_i64 addr, int mem_index)
{



    tcg_gen_op4i_i32(INDEX_op_qemu_st32, (arg), (addr),
                     ((addr) + 1), mem_index);

}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_qemu_st64(TCGv_i64 arg, TCGv_i64 addr, int mem_index)
{




    tcg_gen_op5i_i32(INDEX_op_qemu_st64, (arg), ((arg) + 1),
                     (addr), ((addr) + 1), mem_index);

}
# 30 "../../target-i386/translate.c" 2

# 1 "../../target-i386/helper.h" 1
# 1 "../../def-helper.h" 1
# 2 "../../target-i386/helper.h" 2

uint32_t helper_cc_compute_all (int);
uint32_t helper_cc_compute_c (int);

void helper_lock (void);
void helper_unlock (void);
void helper_write_eflags (target_ulong, uint32_t);
target_ulong helper_read_eflags (void);
void helper_divb_AL (target_ulong);
void helper_idivb_AL (target_ulong);
void helper_divw_AX (target_ulong);
void helper_idivw_AX (target_ulong);
void helper_divl_EAX (target_ulong);
void helper_idivl_EAX (target_ulong);

void helper_mulq_EAX_T0 (target_ulong);
void helper_imulq_EAX_T0 (target_ulong);
target_ulong helper_imulq_T0_T1 (target_ulong, target_ulong);
void helper_divq_EAX (target_ulong);
void helper_idivq_EAX (target_ulong);


void helper_aam (int);
void helper_aad (int);
void helper_aaa (void);
void helper_aas (void);
void helper_daa (void);
void helper_das (void);

target_ulong helper_lsl (target_ulong);
target_ulong helper_lar (target_ulong);
void helper_verr (target_ulong);
void helper_verw (target_ulong);
void helper_lldt (int);
void helper_ltr (int);
void helper_load_seg (int, int);
void helper_ljmp_protected (int, target_ulong, int);
void helper_lcall_real (int, target_ulong, int, int);
void helper_lcall_protected (int, target_ulong, int, int);
void helper_iret_real (int);
void helper_iret_protected (int, int);
void helper_lret_protected (int, int);
target_ulong helper_read_crN (int);
void helper_write_crN (int, target_ulong);
void helper_lmsw (target_ulong);
void helper_clts (void);
void helper_movl_drN_T0 (int, target_ulong);
void helper_invlpg (target_ulong);

void helper_enter_level (int, int, target_ulong);

void helper_enter64_level (int, int, target_ulong);

void helper_sysenter (void);
void helper_sysexit (int);

void helper_syscall (int);
void helper_sysret (int);

void helper_hlt (int);
void helper_monitor (target_ulong);
void helper_mwait (int);
void helper_debug (void);
void helper_reset_rf (void);
void helper_raise_interrupt (int, int);
void helper_raise_exception (int);
void helper_cli (void);
void helper_sti (void);
void helper_set_inhibit_irq (void);
void helper_reset_inhibit_irq (void);
void helper_boundw (target_ulong, int);
void helper_boundl (target_ulong, int);
void helper_rsm (void);
void helper_into (int);
void helper_cmpxchg8b (target_ulong);

void helper_cmpxchg16b (target_ulong);

void helper_single_step (void);
void helper_cpuid (void);
void helper_rdtsc (void);
void helper_rdtscp (void);
void helper_rdpmc (void);
void helper_rdmsr (void);
void helper_wrmsr (void);

void helper_check_iob (uint32_t);
void helper_check_iow (uint32_t);
void helper_check_iol (uint32_t);
void helper_outb (uint32_t, uint32_t);
target_ulong helper_inb (uint32_t);
void helper_outw (uint32_t, uint32_t);
target_ulong helper_inw (uint32_t);
void helper_outl (uint32_t, uint32_t);
target_ulong helper_inl (uint32_t);

void helper_svm_check_intercept_param (uint32_t, uint64_t);
void helper_vmexit (uint32_t, uint64_t);
void helper_svm_check_io (uint32_t, uint32_t, uint32_t);
void helper_vmrun (int, int);
void helper_vmmcall (void);
void helper_vmload (int);
void helper_vmsave (int);
void helper_stgi (void);
void helper_clgi (void);
void helper_skinit (void);
void helper_invlpga (int);



void helper_flds_FT0 (uint32_t);
void helper_fldl_FT0 (uint64_t);
void helper_fildl_FT0 (int32_t);
void helper_flds_ST0 (uint32_t);
void helper_fldl_ST0 (uint64_t);
void helper_fildl_ST0 (int32_t);
void helper_fildll_ST0 (int64_t);
uint32_t helper_fsts_ST0 (void);
uint64_t helper_fstl_ST0 (void);
int32_t helper_fist_ST0 (void);
int32_t helper_fistl_ST0 (void);
int64_t helper_fistll_ST0 (void);
int32_t helper_fistt_ST0 (void);
int32_t helper_fisttl_ST0 (void);
int64_t helper_fisttll_ST0 (void);
void helper_fldt_ST0 (target_ulong);
void helper_fstt_ST0 (target_ulong);
void helper_fpush (void);
void helper_fpop (void);
void helper_fdecstp (void);
void helper_fincstp (void);
void helper_ffree_STN (int);
void helper_fmov_ST0_FT0 (void);
void helper_fmov_FT0_STN (int);
void helper_fmov_ST0_STN (int);
void helper_fmov_STN_ST0 (int);
void helper_fxchg_ST0_STN (int);
void helper_fcom_ST0_FT0 (void);
void helper_fucom_ST0_FT0 (void);
void helper_fcomi_ST0_FT0 (void);
void helper_fucomi_ST0_FT0 (void);
void helper_fadd_ST0_FT0 (void);
void helper_fmul_ST0_FT0 (void);
void helper_fsub_ST0_FT0 (void);
void helper_fsubr_ST0_FT0 (void);
void helper_fdiv_ST0_FT0 (void);
void helper_fdivr_ST0_FT0 (void);
void helper_fadd_STN_ST0 (int);
void helper_fmul_STN_ST0 (int);
void helper_fsub_STN_ST0 (int);
void helper_fsubr_STN_ST0 (int);
void helper_fdiv_STN_ST0 (int);
void helper_fdivr_STN_ST0 (int);
void helper_fchs_ST0 (void);
void helper_fabs_ST0 (void);
void helper_fxam_ST0 (void);
void helper_fld1_ST0 (void);
void helper_fldl2t_ST0 (void);
void helper_fldl2e_ST0 (void);
void helper_fldpi_ST0 (void);
void helper_fldlg2_ST0 (void);
void helper_fldln2_ST0 (void);
void helper_fldz_ST0 (void);
void helper_fldz_FT0 (void);
uint32_t helper_fnstsw (void);
uint32_t helper_fnstcw (void);
void helper_fldcw (uint32_t);
void helper_fclex (void);
void helper_fwait (void);
void helper_fninit (void);
void helper_fbld_ST0 (target_ulong);
void helper_fbst_ST0 (target_ulong);
void helper_f2xm1 (void);
void helper_fyl2x (void);
void helper_fptan (void);
void helper_fpatan (void);
void helper_fxtract (void);
void helper_fprem1 (void);
void helper_fprem (void);
void helper_fyl2xp1 (void);
void helper_fsqrt (void);
void helper_fsincos (void);
void helper_frndint (void);
void helper_fscale (void);
void helper_fsin (void);
void helper_fcos (void);
void helper_fstenv (target_ulong, int);
void helper_fldenv (target_ulong, int);
void helper_fsave (target_ulong, int);
void helper_frstor (target_ulong, int);
void helper_fxsave (target_ulong, int);
void helper_fxrstor (target_ulong, int);
target_ulong helper_bsf (target_ulong);
target_ulong helper_bsr (target_ulong);
target_ulong helper_lzcnt (target_ulong, int);



void helper_enter_mmx (void);
void helper_emms (void);
void helper_movq (void *, void *);


# 1 "../../target-i386/ops_sse_header.h" 1
# 37 "../../target-i386/ops_sse_header.h"
void helper_psrlw_mmx (MMXReg *, MMXReg *);
void helper_psraw_mmx (MMXReg *, MMXReg *);
void helper_psllw_mmx (MMXReg *, MMXReg *);
void helper_psrld_mmx (MMXReg *, MMXReg *);
void helper_psrad_mmx (MMXReg *, MMXReg *);
void helper_pslld_mmx (MMXReg *, MMXReg *);
void helper_psrlq_mmx (MMXReg *, MMXReg *);
void helper_psllq_mmx (MMXReg *, MMXReg *);
# 63 "../../target-i386/ops_sse_header.h"
void helper_paddb_mmx (MMXReg *, MMXReg *);
void helper_paddw_mmx (MMXReg *, MMXReg *);
void helper_paddl_mmx (MMXReg *, MMXReg *);
void helper_paddq_mmx (MMXReg *, MMXReg *);

void helper_psubb_mmx (MMXReg *, MMXReg *);
void helper_psubw_mmx (MMXReg *, MMXReg *);
void helper_psubl_mmx (MMXReg *, MMXReg *);
void helper_psubq_mmx (MMXReg *, MMXReg *);

void helper_paddusb_mmx (MMXReg *, MMXReg *);
void helper_paddsb_mmx (MMXReg *, MMXReg *);
void helper_psubusb_mmx (MMXReg *, MMXReg *);
void helper_psubsb_mmx (MMXReg *, MMXReg *);

void helper_paddusw_mmx (MMXReg *, MMXReg *);
void helper_paddsw_mmx (MMXReg *, MMXReg *);
void helper_psubusw_mmx (MMXReg *, MMXReg *);
void helper_psubsw_mmx (MMXReg *, MMXReg *);

void helper_pminub_mmx (MMXReg *, MMXReg *);
void helper_pmaxub_mmx (MMXReg *, MMXReg *);

void helper_pminsw_mmx (MMXReg *, MMXReg *);
void helper_pmaxsw_mmx (MMXReg *, MMXReg *);

void helper_pand_mmx (MMXReg *, MMXReg *);
void helper_pandn_mmx (MMXReg *, MMXReg *);
void helper_por_mmx (MMXReg *, MMXReg *);
void helper_pxor_mmx (MMXReg *, MMXReg *);

void helper_pcmpgtb_mmx (MMXReg *, MMXReg *);
void helper_pcmpgtw_mmx (MMXReg *, MMXReg *);
void helper_pcmpgtl_mmx (MMXReg *, MMXReg *);

void helper_pcmpeqb_mmx (MMXReg *, MMXReg *);
void helper_pcmpeqw_mmx (MMXReg *, MMXReg *);
void helper_pcmpeql_mmx (MMXReg *, MMXReg *);

void helper_pmullw_mmx (MMXReg *, MMXReg *);

void helper_pmulhrw_mmx (MMXReg *, MMXReg *);

void helper_pmulhuw_mmx (MMXReg *, MMXReg *);
void helper_pmulhw_mmx (MMXReg *, MMXReg *);

void helper_pavgb_mmx (MMXReg *, MMXReg *);
void helper_pavgw_mmx (MMXReg *, MMXReg *);

void helper_pmuludq_mmx (MMXReg *, MMXReg *);
void helper_pmaddwd_mmx (MMXReg *, MMXReg *);

void helper_psadbw_mmx (MMXReg *, MMXReg *);
void helper_maskmov_mmx (MMXReg *, MMXReg *, target_ulong);
void helper_movl_mm_T0_mmx (MMXReg *, uint32_t);

void helper_movq_mm_T0_mmx (MMXReg *, uint64_t);



void helper_pshufw_mmx (MMXReg *, MMXReg *, int);
# 227 "../../target-i386/ops_sse_header.h"
uint32_t helper_pmovmskb_mmx (MMXReg *);
void helper_packsswb_mmx (MMXReg *, MMXReg *);
void helper_packuswb_mmx (MMXReg *, MMXReg *);
void helper_packssdw_mmx (MMXReg *, MMXReg *);





void helper_punpcklbw_mmx (MMXReg *, MMXReg *); void helper_punpcklwd_mmx (MMXReg *, MMXReg *); void helper_punpckldq_mmx (MMXReg *, MMXReg *);
void helper_punpckhbw_mmx (MMXReg *, MMXReg *); void helper_punpckhwd_mmx (MMXReg *, MMXReg *); void helper_punpckhdq_mmx (MMXReg *, MMXReg *);
# 246 "../../target-i386/ops_sse_header.h"
void helper_pi2fd (MMXReg *, MMXReg *);
void helper_pi2fw (MMXReg *, MMXReg *);
void helper_pf2id (MMXReg *, MMXReg *);
void helper_pf2iw (MMXReg *, MMXReg *);
void helper_pfacc (MMXReg *, MMXReg *);
void helper_pfadd (MMXReg *, MMXReg *);
void helper_pfcmpeq (MMXReg *, MMXReg *);
void helper_pfcmpge (MMXReg *, MMXReg *);
void helper_pfcmpgt (MMXReg *, MMXReg *);
void helper_pfmax (MMXReg *, MMXReg *);
void helper_pfmin (MMXReg *, MMXReg *);
void helper_pfmul (MMXReg *, MMXReg *);
void helper_pfnacc (MMXReg *, MMXReg *);
void helper_pfpnacc (MMXReg *, MMXReg *);
void helper_pfrcp (MMXReg *, MMXReg *);
void helper_pfrsqrt (MMXReg *, MMXReg *);
void helper_pfsub (MMXReg *, MMXReg *);
void helper_pfsubr (MMXReg *, MMXReg *);
void helper_pswapd (MMXReg *, MMXReg *);



void helper_phaddw_mmx (MMXReg *, MMXReg *);
void helper_phaddd_mmx (MMXReg *, MMXReg *);
void helper_phaddsw_mmx (MMXReg *, MMXReg *);
void helper_phsubw_mmx (MMXReg *, MMXReg *);
void helper_phsubd_mmx (MMXReg *, MMXReg *);
void helper_phsubsw_mmx (MMXReg *, MMXReg *);
void helper_pabsb_mmx (MMXReg *, MMXReg *);
void helper_pabsw_mmx (MMXReg *, MMXReg *);
void helper_pabsd_mmx (MMXReg *, MMXReg *);
void helper_pmaddubsw_mmx (MMXReg *, MMXReg *);
void helper_pmulhrsw_mmx (MMXReg *, MMXReg *);
void helper_pshufb_mmx (MMXReg *, MMXReg *);
void helper_psignb_mmx (MMXReg *, MMXReg *);
void helper_psignw_mmx (MMXReg *, MMXReg *);
void helper_psignd_mmx (MMXReg *, MMXReg *);
void helper_palignr_mmx (MMXReg *, MMXReg *, int32_t);
# 206 "../../target-i386/helper.h" 2

# 1 "../../target-i386/ops_sse_header.h" 1
# 37 "../../target-i386/ops_sse_header.h"
void helper_psrlw_xmm (XMMReg *, XMMReg *);
void helper_psraw_xmm (XMMReg *, XMMReg *);
void helper_psllw_xmm (XMMReg *, XMMReg *);
void helper_psrld_xmm (XMMReg *, XMMReg *);
void helper_psrad_xmm (XMMReg *, XMMReg *);
void helper_pslld_xmm (XMMReg *, XMMReg *);
void helper_psrlq_xmm (XMMReg *, XMMReg *);
void helper_psllq_xmm (XMMReg *, XMMReg *);


void helper_psrldq_xmm (XMMReg *, XMMReg *);
void helper_pslldq_xmm (XMMReg *, XMMReg *);
# 63 "../../target-i386/ops_sse_header.h"
void helper_paddb_xmm (XMMReg *, XMMReg *);
void helper_paddw_xmm (XMMReg *, XMMReg *);
void helper_paddl_xmm (XMMReg *, XMMReg *);
void helper_paddq_xmm (XMMReg *, XMMReg *);

void helper_psubb_xmm (XMMReg *, XMMReg *);
void helper_psubw_xmm (XMMReg *, XMMReg *);
void helper_psubl_xmm (XMMReg *, XMMReg *);
void helper_psubq_xmm (XMMReg *, XMMReg *);

void helper_paddusb_xmm (XMMReg *, XMMReg *);
void helper_paddsb_xmm (XMMReg *, XMMReg *);
void helper_psubusb_xmm (XMMReg *, XMMReg *);
void helper_psubsb_xmm (XMMReg *, XMMReg *);

void helper_paddusw_xmm (XMMReg *, XMMReg *);
void helper_paddsw_xmm (XMMReg *, XMMReg *);
void helper_psubusw_xmm (XMMReg *, XMMReg *);
void helper_psubsw_xmm (XMMReg *, XMMReg *);

void helper_pminub_xmm (XMMReg *, XMMReg *);
void helper_pmaxub_xmm (XMMReg *, XMMReg *);

void helper_pminsw_xmm (XMMReg *, XMMReg *);
void helper_pmaxsw_xmm (XMMReg *, XMMReg *);

void helper_pand_xmm (XMMReg *, XMMReg *);
void helper_pandn_xmm (XMMReg *, XMMReg *);
void helper_por_xmm (XMMReg *, XMMReg *);
void helper_pxor_xmm (XMMReg *, XMMReg *);

void helper_pcmpgtb_xmm (XMMReg *, XMMReg *);
void helper_pcmpgtw_xmm (XMMReg *, XMMReg *);
void helper_pcmpgtl_xmm (XMMReg *, XMMReg *);

void helper_pcmpeqb_xmm (XMMReg *, XMMReg *);
void helper_pcmpeqw_xmm (XMMReg *, XMMReg *);
void helper_pcmpeql_xmm (XMMReg *, XMMReg *);

void helper_pmullw_xmm (XMMReg *, XMMReg *);



void helper_pmulhuw_xmm (XMMReg *, XMMReg *);
void helper_pmulhw_xmm (XMMReg *, XMMReg *);

void helper_pavgb_xmm (XMMReg *, XMMReg *);
void helper_pavgw_xmm (XMMReg *, XMMReg *);

void helper_pmuludq_xmm (XMMReg *, XMMReg *);
void helper_pmaddwd_xmm (XMMReg *, XMMReg *);

void helper_psadbw_xmm (XMMReg *, XMMReg *);
void helper_maskmov_xmm (XMMReg *, XMMReg *, target_ulong);
void helper_movl_mm_T0_xmm (XMMReg *, uint32_t);

void helper_movq_mm_T0_xmm (XMMReg *, uint64_t);





void helper_shufps (XMMReg *, XMMReg *, int);
void helper_shufpd (XMMReg *, XMMReg *, int);
void helper_pshufd_xmm (XMMReg *, XMMReg *, int);
void helper_pshuflw_xmm (XMMReg *, XMMReg *, int);
void helper_pshufhw_xmm (XMMReg *, XMMReg *, int);
# 142 "../../target-i386/ops_sse_header.h"
void helper_addps (XMMReg *, XMMReg *); void helper_addss (XMMReg *, XMMReg *); void helper_addpd (XMMReg *, XMMReg *); void helper_addsd (XMMReg *, XMMReg *);
void helper_subps (XMMReg *, XMMReg *); void helper_subss (XMMReg *, XMMReg *); void helper_subpd (XMMReg *, XMMReg *); void helper_subsd (XMMReg *, XMMReg *);
void helper_mulps (XMMReg *, XMMReg *); void helper_mulss (XMMReg *, XMMReg *); void helper_mulpd (XMMReg *, XMMReg *); void helper_mulsd (XMMReg *, XMMReg *);
void helper_divps (XMMReg *, XMMReg *); void helper_divss (XMMReg *, XMMReg *); void helper_divpd (XMMReg *, XMMReg *); void helper_divsd (XMMReg *, XMMReg *);
void helper_minps (XMMReg *, XMMReg *); void helper_minss (XMMReg *, XMMReg *); void helper_minpd (XMMReg *, XMMReg *); void helper_minsd (XMMReg *, XMMReg *);
void helper_maxps (XMMReg *, XMMReg *); void helper_maxss (XMMReg *, XMMReg *); void helper_maxpd (XMMReg *, XMMReg *); void helper_maxsd (XMMReg *, XMMReg *);
void helper_sqrtps (XMMReg *, XMMReg *); void helper_sqrtss (XMMReg *, XMMReg *); void helper_sqrtpd (XMMReg *, XMMReg *); void helper_sqrtsd (XMMReg *, XMMReg *);


void helper_cvtps2pd (XMMReg *, XMMReg *);
void helper_cvtpd2ps (XMMReg *, XMMReg *);
void helper_cvtss2sd (XMMReg *, XMMReg *);
void helper_cvtsd2ss (XMMReg *, XMMReg *);
void helper_cvtdq2ps (XMMReg *, XMMReg *);
void helper_cvtdq2pd (XMMReg *, XMMReg *);
void helper_cvtpi2ps (XMMReg *, MMXReg *);
void helper_cvtpi2pd (XMMReg *, MMXReg *);
void helper_cvtsi2ss (XMMReg *, uint32_t);
void helper_cvtsi2sd (XMMReg *, uint32_t);


void helper_cvtsq2ss (XMMReg *, uint64_t);
void helper_cvtsq2sd (XMMReg *, uint64_t);


void helper_cvtps2dq (XMMReg *, XMMReg *);
void helper_cvtpd2dq (XMMReg *, XMMReg *);
void helper_cvtps2pi (MMXReg *, XMMReg *);
void helper_cvtpd2pi (MMXReg *, XMMReg *);
int32_t helper_cvtss2si (XMMReg *);
int32_t helper_cvtsd2si (XMMReg *);

int64_t helper_cvtss2sq (XMMReg *);
int64_t helper_cvtsd2sq (XMMReg *);


void helper_cvttps2dq (XMMReg *, XMMReg *);
void helper_cvttpd2dq (XMMReg *, XMMReg *);
void helper_cvttps2pi (MMXReg *, XMMReg *);
void helper_cvttpd2pi (MMXReg *, XMMReg *);
int32_t helper_cvttss2si (XMMReg *);
int32_t helper_cvttsd2si (XMMReg *);

int64_t helper_cvttss2sq (XMMReg *);
int64_t helper_cvttsd2sq (XMMReg *);


void helper_rsqrtps (XMMReg *, XMMReg *);
void helper_rsqrtss (XMMReg *, XMMReg *);
void helper_rcpps (XMMReg *, XMMReg *);
void helper_rcpss (XMMReg *, XMMReg *);
void helper_extrq_r (XMMReg *, XMMReg *);
void helper_extrq_i (XMMReg *, int, int);
void helper_insertq_r (XMMReg *, XMMReg *);
void helper_insertq_i (XMMReg *, int, int);
void helper_haddps (XMMReg *, XMMReg *);
void helper_haddpd (XMMReg *, XMMReg *);
void helper_hsubps (XMMReg *, XMMReg *);
void helper_hsubpd (XMMReg *, XMMReg *);
void helper_addsubps (XMMReg *, XMMReg *);
void helper_addsubpd (XMMReg *, XMMReg *);







void helper_cmpeqps (XMMReg *, XMMReg *); void helper_cmpeqss (XMMReg *, XMMReg *); void helper_cmpeqpd (XMMReg *, XMMReg *); void helper_cmpeqsd (XMMReg *, XMMReg *);
void helper_cmpltps (XMMReg *, XMMReg *); void helper_cmpltss (XMMReg *, XMMReg *); void helper_cmpltpd (XMMReg *, XMMReg *); void helper_cmpltsd (XMMReg *, XMMReg *);
void helper_cmpleps (XMMReg *, XMMReg *); void helper_cmpless (XMMReg *, XMMReg *); void helper_cmplepd (XMMReg *, XMMReg *); void helper_cmplesd (XMMReg *, XMMReg *);
void helper_cmpunordps (XMMReg *, XMMReg *); void helper_cmpunordss (XMMReg *, XMMReg *); void helper_cmpunordpd (XMMReg *, XMMReg *); void helper_cmpunordsd (XMMReg *, XMMReg *);
void helper_cmpneqps (XMMReg *, XMMReg *); void helper_cmpneqss (XMMReg *, XMMReg *); void helper_cmpneqpd (XMMReg *, XMMReg *); void helper_cmpneqsd (XMMReg *, XMMReg *);
void helper_cmpnltps (XMMReg *, XMMReg *); void helper_cmpnltss (XMMReg *, XMMReg *); void helper_cmpnltpd (XMMReg *, XMMReg *); void helper_cmpnltsd (XMMReg *, XMMReg *);
void helper_cmpnleps (XMMReg *, XMMReg *); void helper_cmpnless (XMMReg *, XMMReg *); void helper_cmpnlepd (XMMReg *, XMMReg *); void helper_cmpnlesd (XMMReg *, XMMReg *);
void helper_cmpordps (XMMReg *, XMMReg *); void helper_cmpordss (XMMReg *, XMMReg *); void helper_cmpordpd (XMMReg *, XMMReg *); void helper_cmpordsd (XMMReg *, XMMReg *);

void helper_ucomiss (XMMReg *, XMMReg *);
void helper_comiss (XMMReg *, XMMReg *);
void helper_ucomisd (XMMReg *, XMMReg *);
void helper_comisd (XMMReg *, XMMReg *);
uint32_t helper_movmskps (XMMReg *);
uint32_t helper_movmskpd (XMMReg *);


uint32_t helper_pmovmskb_xmm (XMMReg *);
void helper_packsswb_xmm (XMMReg *, XMMReg *);
void helper_packuswb_xmm (XMMReg *, XMMReg *);
void helper_packssdw_xmm (XMMReg *, XMMReg *);





void helper_punpcklbw_xmm (XMMReg *, XMMReg *); void helper_punpcklwd_xmm (XMMReg *, XMMReg *); void helper_punpckldq_xmm (XMMReg *, XMMReg *);
void helper_punpckhbw_xmm (XMMReg *, XMMReg *); void helper_punpckhwd_xmm (XMMReg *, XMMReg *); void helper_punpckhdq_xmm (XMMReg *, XMMReg *);


void helper_punpcklqdq_xmm (XMMReg *, XMMReg *);
void helper_punpckhqdq_xmm (XMMReg *, XMMReg *);
# 268 "../../target-i386/ops_sse_header.h"
void helper_phaddw_xmm (XMMReg *, XMMReg *);
void helper_phaddd_xmm (XMMReg *, XMMReg *);
void helper_phaddsw_xmm (XMMReg *, XMMReg *);
void helper_phsubw_xmm (XMMReg *, XMMReg *);
void helper_phsubd_xmm (XMMReg *, XMMReg *);
void helper_phsubsw_xmm (XMMReg *, XMMReg *);
void helper_pabsb_xmm (XMMReg *, XMMReg *);
void helper_pabsw_xmm (XMMReg *, XMMReg *);
void helper_pabsd_xmm (XMMReg *, XMMReg *);
void helper_pmaddubsw_xmm (XMMReg *, XMMReg *);
void helper_pmulhrsw_xmm (XMMReg *, XMMReg *);
void helper_pshufb_xmm (XMMReg *, XMMReg *);
void helper_psignb_xmm (XMMReg *, XMMReg *);
void helper_psignw_xmm (XMMReg *, XMMReg *);
void helper_psignd_xmm (XMMReg *, XMMReg *);
void helper_palignr_xmm (XMMReg *, XMMReg *, int32_t);



void helper_pblendvb_xmm (XMMReg *, XMMReg *);
void helper_blendvps_xmm (XMMReg *, XMMReg *);
void helper_blendvpd_xmm (XMMReg *, XMMReg *);
void helper_ptest_xmm (XMMReg *, XMMReg *);
void helper_pmovsxbw_xmm (XMMReg *, XMMReg *);
void helper_pmovsxbd_xmm (XMMReg *, XMMReg *);
void helper_pmovsxbq_xmm (XMMReg *, XMMReg *);
void helper_pmovsxwd_xmm (XMMReg *, XMMReg *);
void helper_pmovsxwq_xmm (XMMReg *, XMMReg *);
void helper_pmovsxdq_xmm (XMMReg *, XMMReg *);
void helper_pmovzxbw_xmm (XMMReg *, XMMReg *);
void helper_pmovzxbd_xmm (XMMReg *, XMMReg *);
void helper_pmovzxbq_xmm (XMMReg *, XMMReg *);
void helper_pmovzxwd_xmm (XMMReg *, XMMReg *);
void helper_pmovzxwq_xmm (XMMReg *, XMMReg *);
void helper_pmovzxdq_xmm (XMMReg *, XMMReg *);
void helper_pmuldq_xmm (XMMReg *, XMMReg *);
void helper_pcmpeqq_xmm (XMMReg *, XMMReg *);
void helper_packusdw_xmm (XMMReg *, XMMReg *);
void helper_pminsb_xmm (XMMReg *, XMMReg *);
void helper_pminsd_xmm (XMMReg *, XMMReg *);
void helper_pminuw_xmm (XMMReg *, XMMReg *);
void helper_pminud_xmm (XMMReg *, XMMReg *);
void helper_pmaxsb_xmm (XMMReg *, XMMReg *);
void helper_pmaxsd_xmm (XMMReg *, XMMReg *);
void helper_pmaxuw_xmm (XMMReg *, XMMReg *);
void helper_pmaxud_xmm (XMMReg *, XMMReg *);
void helper_pmulld_xmm (XMMReg *, XMMReg *);
void helper_phminposuw_xmm (XMMReg *, XMMReg *);
void helper_roundps_xmm (XMMReg *, XMMReg *, uint32_t);
void helper_roundpd_xmm (XMMReg *, XMMReg *, uint32_t);
void helper_roundss_xmm (XMMReg *, XMMReg *, uint32_t);
void helper_roundsd_xmm (XMMReg *, XMMReg *, uint32_t);
void helper_blendps_xmm (XMMReg *, XMMReg *, uint32_t);
void helper_blendpd_xmm (XMMReg *, XMMReg *, uint32_t);
void helper_pblendw_xmm (XMMReg *, XMMReg *, uint32_t);
void helper_dpps_xmm (XMMReg *, XMMReg *, uint32_t);
void helper_dppd_xmm (XMMReg *, XMMReg *, uint32_t);
void helper_mpsadbw_xmm (XMMReg *, XMMReg *, uint32_t);




void helper_pcmpgtq_xmm (XMMReg *, XMMReg *);
void helper_pcmpestri_xmm (XMMReg *, XMMReg *, uint32_t);
void helper_pcmpestrm_xmm (XMMReg *, XMMReg *, uint32_t);
void helper_pcmpistri_xmm (XMMReg *, XMMReg *, uint32_t);
void helper_pcmpistrm_xmm (XMMReg *, XMMReg *, uint32_t);
target_ulong helper_crc32 (uint32_t, target_ulong, uint32_t);
target_ulong helper_popcnt (target_ulong, uint32_t);
# 208 "../../target-i386/helper.h" 2

target_ulong helper_rclb (target_ulong, target_ulong);
target_ulong helper_rclw (target_ulong, target_ulong);
target_ulong helper_rcll (target_ulong, target_ulong);
target_ulong helper_rcrb (target_ulong, target_ulong);
target_ulong helper_rcrw (target_ulong, target_ulong);
target_ulong helper_rcrl (target_ulong, target_ulong);

target_ulong helper_rclq (target_ulong, target_ulong);
target_ulong helper_rcrq (target_ulong, target_ulong);


# 1 "../../def-helper.h" 1
# 220 "../../target-i386/helper.h" 2
# 32 "../../target-i386/translate.c" 2

# 1 "../../target-i386/helper.h" 1
# 1 "../../def-helper.h" 1
# 2 "../../target-i386/helper.h" 2

static __attribute__ (( always_inline )) __inline__ void gen_helper_cc_compute_all(TCGv_i32 retval, TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_cc_compute_all, 0x0010, sizemask, (retval), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cc_compute_c(TCGv_i32 retval, TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_cc_compute_c, 0x0010, sizemask, (retval), 1, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_lock(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_lock, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_unlock(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_unlock, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_write_eflags( TCGv_i64 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_write_eflags, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_read_eflags(TCGv_i64 retval) { int sizemask; sizemask = 1; tcg_gen_helperN(helper_read_eflags, 0, sizemask, (retval), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_divb_AL( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_divb_AL, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_idivb_AL( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_idivb_AL, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_divw_AX( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_divw_AX, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_idivw_AX( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_idivw_AX, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_divl_EAX( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_divl_EAX, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_idivl_EAX( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_idivl_EAX, 0, sizemask, ((TCGArg)(-1)), 1, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_mulq_EAX_T0( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_mulq_EAX_T0, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_imulq_EAX_T0( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_imulq_EAX_T0, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_imulq_T0_T1(TCGv_i64 retval, TCGv_i64 arg1, TCGv_i64 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 1 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_imulq_T0_T1, 0, sizemask, (retval), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_divq_EAX( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_divq_EAX, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_idivq_EAX( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_idivq_EAX, 0, sizemask, ((TCGArg)(-1)), 1, args); }


static __attribute__ (( always_inline )) __inline__ void gen_helper_aam( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_aam, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_aad( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_aad, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_aaa(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_aaa, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_aas(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_aas, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_daa(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_daa, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_das(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_das, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_lsl(TCGv_i64 retval, TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_lsl, 0, sizemask, (retval), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_lar(TCGv_i64 retval, TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_lar, 0, sizemask, (retval), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_verr( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_verr, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_verw( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_verw, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_lldt( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_lldt, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_ltr( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_ltr, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_load_seg( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 1 << (2*2+1); tcg_gen_helperN(helper_load_seg, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_ljmp_protected( TCGv_i32 arg1, TCGv_i64 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 1 << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 1 << (3*2+1); tcg_gen_helperN(helper_ljmp_protected, 0, sizemask, ((TCGArg)(-1)), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_lcall_real( TCGv_i32 arg1, TCGv_i64 arg2, TCGv_i32 arg3, TCGv_i32 arg4) { TCGArg args[4]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 1 << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 1 << (3*2+1); args[4 - 1] = (arg4); sizemask |= 0 << (4*2); sizemask |= 1 << (4*2+1); tcg_gen_helperN(helper_lcall_real, 0, sizemask, ((TCGArg)(-1)), 4, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_lcall_protected( TCGv_i32 arg1, TCGv_i64 arg2, TCGv_i32 arg3, TCGv_i32 arg4) { TCGArg args[4]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 1 << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 1 << (3*2+1); args[4 - 1] = (arg4); sizemask |= 0 << (4*2); sizemask |= 1 << (4*2+1); tcg_gen_helperN(helper_lcall_protected, 0, sizemask, ((TCGArg)(-1)), 4, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_iret_real( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_iret_real, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_iret_protected( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 1 << (2*2+1); tcg_gen_helperN(helper_iret_protected, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_lret_protected( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 1 << (2*2+1); tcg_gen_helperN(helper_lret_protected, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_read_crN(TCGv_i64 retval, TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_read_crN, 0, sizemask, (retval), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_write_crN( TCGv_i32 arg1, TCGv_i64 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 1 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_write_crN, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_lmsw( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_lmsw, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_clts(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_clts, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_movl_drN_T0( TCGv_i32 arg1, TCGv_i64 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 1 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_movl_drN_T0, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_invlpg( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_invlpg, 0, sizemask, ((TCGArg)(-1)), 1, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_enter_level( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i64 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 1 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 1 << (3*2); sizemask |= 0 << (3*2+1); tcg_gen_helperN(helper_enter_level, 0, sizemask, ((TCGArg)(-1)), 3, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_enter64_level( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i64 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 1 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 1 << (3*2); sizemask |= 0 << (3*2+1); tcg_gen_helperN(helper_enter64_level, 0, sizemask, ((TCGArg)(-1)), 3, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_sysenter(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_sysenter, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_sysexit( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_sysexit, 0, sizemask, ((TCGArg)(-1)), 1, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_syscall( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_syscall, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_sysret( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_sysret, 0, sizemask, ((TCGArg)(-1)), 1, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_hlt( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_hlt, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_monitor( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_monitor, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_mwait( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_mwait, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_debug(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_debug, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_reset_rf(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_reset_rf, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_raise_interrupt( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 1 << (2*2+1); tcg_gen_helperN(helper_raise_interrupt, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_raise_exception( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_raise_exception, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cli(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_cli, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_sti(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_sti, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_set_inhibit_irq(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_set_inhibit_irq, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_reset_inhibit_irq(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_reset_inhibit_irq, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_boundw( TCGv_i64 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 1 << (2*2+1); tcg_gen_helperN(helper_boundw, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_boundl( TCGv_i64 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 1 << (2*2+1); tcg_gen_helperN(helper_boundl, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_rsm(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_rsm, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_into( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_into, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpxchg8b( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_cmpxchg8b, 0, sizemask, ((TCGArg)(-1)), 1, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpxchg16b( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_cmpxchg16b, 0, sizemask, ((TCGArg)(-1)), 1, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_single_step(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_single_step, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cpuid(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_cpuid, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_rdtsc(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_rdtsc, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_rdtscp(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_rdtscp, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_rdpmc(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_rdpmc, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_rdmsr(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_rdmsr, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_wrmsr(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_wrmsr, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_check_iob( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_check_iob, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_check_iow( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_check_iow, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_check_iol( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_check_iol, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_outb( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_outb, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_inb(TCGv_i64 retval, TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_inb, 0, sizemask, (retval), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_outw( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_outw, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_inw(TCGv_i64 retval, TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_inw, 0, sizemask, (retval), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_outl( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_outl, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_inl(TCGv_i64 retval, TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_inl, 0, sizemask, (retval), 1, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_svm_check_intercept_param( TCGv_i32 arg1, TCGv_i64 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 1 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_svm_check_intercept_param, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_vmexit( TCGv_i32 arg1, TCGv_i64 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 1 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_vmexit, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_svm_check_io( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 0 << (3*2+1); tcg_gen_helperN(helper_svm_check_io, 0, sizemask, ((TCGArg)(-1)), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_vmrun( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 1 << (2*2+1); tcg_gen_helperN(helper_vmrun, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_vmmcall(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_vmmcall, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_vmload( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_vmload, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_vmsave( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_vmsave, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_stgi(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_stgi, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_clgi(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_clgi, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_skinit(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_skinit, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_invlpga( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_invlpga, 0, sizemask, ((TCGArg)(-1)), 1, args); }



static __attribute__ (( always_inline )) __inline__ void gen_helper_flds_FT0( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_flds_FT0, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fldl_FT0( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_fldl_FT0, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fildl_FT0( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_fildl_FT0, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_flds_ST0( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_flds_ST0, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fldl_ST0( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_fldl_ST0, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fildl_ST0( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_fildl_ST0, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fildll_ST0( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_fildll_ST0, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fsts_ST0(TCGv_i32 retval) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fsts_ST0, 0, sizemask, (retval), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fstl_ST0(TCGv_i64 retval) { int sizemask; sizemask = 1; tcg_gen_helperN(helper_fstl_ST0, 0, sizemask, (retval), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fist_ST0(TCGv_i32 retval) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fist_ST0, 0, sizemask, (retval), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fistl_ST0(TCGv_i32 retval) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fistl_ST0, 0, sizemask, (retval), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fistll_ST0(TCGv_i64 retval) { int sizemask; sizemask = 1; tcg_gen_helperN(helper_fistll_ST0, 0, sizemask, (retval), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fistt_ST0(TCGv_i32 retval) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fistt_ST0, 0, sizemask, (retval), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fisttl_ST0(TCGv_i32 retval) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fisttl_ST0, 0, sizemask, (retval), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fisttll_ST0(TCGv_i64 retval) { int sizemask; sizemask = 1; tcg_gen_helperN(helper_fisttll_ST0, 0, sizemask, (retval), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fldt_ST0( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_fldt_ST0, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fstt_ST0( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_fstt_ST0, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fpush(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fpush, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fpop(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fpop, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fdecstp(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fdecstp, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fincstp(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fincstp, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_ffree_STN( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_ffree_STN, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fmov_ST0_FT0(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fmov_ST0_FT0, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fmov_FT0_STN( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_fmov_FT0_STN, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fmov_ST0_STN( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_fmov_ST0_STN, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fmov_STN_ST0( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_fmov_STN_ST0, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fxchg_ST0_STN( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_fxchg_ST0_STN, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fcom_ST0_FT0(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fcom_ST0_FT0, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fucom_ST0_FT0(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fucom_ST0_FT0, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fcomi_ST0_FT0(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fcomi_ST0_FT0, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fucomi_ST0_FT0(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fucomi_ST0_FT0, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fadd_ST0_FT0(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fadd_ST0_FT0, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fmul_ST0_FT0(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fmul_ST0_FT0, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fsub_ST0_FT0(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fsub_ST0_FT0, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fsubr_ST0_FT0(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fsubr_ST0_FT0, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fdiv_ST0_FT0(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fdiv_ST0_FT0, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fdivr_ST0_FT0(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fdivr_ST0_FT0, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fadd_STN_ST0( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_fadd_STN_ST0, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fmul_STN_ST0( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_fmul_STN_ST0, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fsub_STN_ST0( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_fsub_STN_ST0, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fsubr_STN_ST0( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_fsubr_STN_ST0, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fdiv_STN_ST0( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_fdiv_STN_ST0, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fdivr_STN_ST0( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 1 << (1*2+1); tcg_gen_helperN(helper_fdivr_STN_ST0, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fchs_ST0(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fchs_ST0, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fabs_ST0(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fabs_ST0, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fxam_ST0(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fxam_ST0, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fld1_ST0(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fld1_ST0, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fldl2t_ST0(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fldl2t_ST0, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fldl2e_ST0(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fldl2e_ST0, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fldpi_ST0(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fldpi_ST0, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fldlg2_ST0(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fldlg2_ST0, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fldln2_ST0(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fldln2_ST0, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fldz_ST0(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fldz_ST0, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fldz_FT0(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fldz_FT0, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fnstsw(TCGv_i32 retval) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fnstsw, 0, sizemask, (retval), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fnstcw(TCGv_i32 retval) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fnstcw, 0, sizemask, (retval), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fldcw( TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_fldcw, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fclex(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fclex, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fwait(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fwait, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fninit(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fninit, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fbld_ST0( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_fbld_ST0, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fbst_ST0( TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_fbst_ST0, 0, sizemask, ((TCGArg)(-1)), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_f2xm1(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_f2xm1, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fyl2x(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fyl2x, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fptan(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fptan, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fpatan(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fpatan, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fxtract(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fxtract, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fprem1(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fprem1, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fprem(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fprem, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fyl2xp1(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fyl2xp1, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fsqrt(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fsqrt, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fsincos(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fsincos, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_frndint(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_frndint, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fscale(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fscale, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fsin(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fsin, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fcos(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_fcos, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fstenv( TCGv_i64 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 1 << (2*2+1); tcg_gen_helperN(helper_fstenv, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fldenv( TCGv_i64 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 1 << (2*2+1); tcg_gen_helperN(helper_fldenv, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fsave( TCGv_i64 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 1 << (2*2+1); tcg_gen_helperN(helper_fsave, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_frstor( TCGv_i64 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 1 << (2*2+1); tcg_gen_helperN(helper_frstor, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fxsave( TCGv_i64 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 1 << (2*2+1); tcg_gen_helperN(helper_fxsave, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_fxrstor( TCGv_i64 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 1 << (2*2+1); tcg_gen_helperN(helper_fxrstor, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_bsf(TCGv_i64 retval, TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_bsf, 0, sizemask, (retval), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_bsr(TCGv_i64 retval, TCGv_i64 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_bsr, 0, sizemask, (retval), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_lzcnt(TCGv_i64 retval, TCGv_i64 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 1 << (2*2+1); tcg_gen_helperN(helper_lzcnt, 0, sizemask, (retval), 2, args); }



static __attribute__ (( always_inline )) __inline__ void gen_helper_enter_mmx(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_enter_mmx, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_emms(void) { int sizemask; sizemask = 0; tcg_gen_helperN(helper_emms, 0, sizemask, ((TCGArg)(-1)), 0, ((void *)0)); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_movq( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_movq, 0, sizemask, ((TCGArg)(-1)), 2, args); }


# 1 "../../target-i386/ops_sse_header.h" 1
# 37 "../../target-i386/ops_sse_header.h"
static __attribute__ (( always_inline )) __inline__ void gen_helper_psrlw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psrlw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psraw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psraw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psllw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psllw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psrld_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psrld_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psrad_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psrad_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pslld_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pslld_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psrlq_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psrlq_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psllq_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psllq_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
# 63 "../../target-i386/ops_sse_header.h"
static __attribute__ (( always_inline )) __inline__ void gen_helper_paddb_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_paddb_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_paddw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_paddw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_paddl_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_paddl_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_paddq_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_paddq_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_psubb_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psubb_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psubw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psubw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psubl_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psubl_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psubq_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psubq_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_paddusb_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_paddusb_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_paddsb_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_paddsb_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psubusb_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psubusb_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psubsb_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psubsb_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_paddusw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_paddusw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_paddsw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_paddsw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psubusw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psubusw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psubsw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psubsw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_pminub_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pminub_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmaxub_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmaxub_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_pminsw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pminsw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmaxsw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmaxsw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_pand_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pand_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pandn_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pandn_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_por_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_por_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pxor_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pxor_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_pcmpgtb_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pcmpgtb_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pcmpgtw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pcmpgtw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pcmpgtl_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pcmpgtl_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_pcmpeqb_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pcmpeqb_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pcmpeqw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pcmpeqw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pcmpeql_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pcmpeql_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_pmullw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmullw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_pmulhrw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmulhrw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_pmulhuw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmulhuw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmulhw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmulhw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_pavgb_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pavgb_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pavgw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pavgw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_pmuludq_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmuludq_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmaddwd_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmaddwd_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_psadbw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psadbw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_maskmov_mmx( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i64 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 1 << (3*2); sizemask |= 0 << (3*2+1); tcg_gen_helperN(helper_maskmov_mmx, 0, sizemask, ((TCGArg)(-1)), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_movl_mm_T0_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_movl_mm_T0_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_movq_mm_T0_mmx( TCGv_i32 arg1, TCGv_i64 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 1 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_movq_mm_T0_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }



static __attribute__ (( always_inline )) __inline__ void gen_helper_pshufw_mmx( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 1 << (3*2+1); tcg_gen_helperN(helper_pshufw_mmx, 0, sizemask, ((TCGArg)(-1)), 3, args); }
# 227 "../../target-i386/ops_sse_header.h"
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmovmskb_mmx(TCGv_i32 retval, TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_pmovmskb_mmx, 0, sizemask, (retval), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_packsswb_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_packsswb_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_packuswb_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_packuswb_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_packssdw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_packssdw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }





static __attribute__ (( always_inline )) __inline__ void gen_helper_punpcklbw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_punpcklbw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_punpcklwd_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_punpcklwd_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_punpckldq_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_punpckldq_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_punpckhbw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_punpckhbw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_punpckhwd_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_punpckhwd_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_punpckhdq_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_punpckhdq_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
# 246 "../../target-i386/ops_sse_header.h"
static __attribute__ (( always_inline )) __inline__ void gen_helper_pi2fd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pi2fd, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pi2fw( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pi2fw, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pf2id( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pf2id, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pf2iw( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pf2iw, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pfacc( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pfacc, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pfadd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pfadd, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pfcmpeq( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pfcmpeq, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pfcmpge( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pfcmpge, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pfcmpgt( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pfcmpgt, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pfmax( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pfmax, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pfmin( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pfmin, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pfmul( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pfmul, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pfnacc( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pfnacc, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pfpnacc( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pfpnacc, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pfrcp( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pfrcp, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pfrsqrt( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pfrsqrt, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pfsub( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pfsub, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pfsubr( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pfsubr, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pswapd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pswapd, 0, sizemask, ((TCGArg)(-1)), 2, args); }



static __attribute__ (( always_inline )) __inline__ void gen_helper_phaddw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_phaddw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_phaddd_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_phaddd_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_phaddsw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_phaddsw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_phsubw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_phsubw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_phsubd_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_phsubd_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_phsubsw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_phsubsw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pabsb_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pabsb_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pabsw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pabsw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pabsd_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pabsd_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmaddubsw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmaddubsw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmulhrsw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmulhrsw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pshufb_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pshufb_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psignb_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psignb_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psignw_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psignw_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psignd_mmx( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psignd_mmx, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_palignr_mmx( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 1 << (3*2+1); tcg_gen_helperN(helper_palignr_mmx, 0, sizemask, ((TCGArg)(-1)), 3, args); }
# 206 "../../target-i386/helper.h" 2

# 1 "../../target-i386/ops_sse_header.h" 1
# 37 "../../target-i386/ops_sse_header.h"
static __attribute__ (( always_inline )) __inline__ void gen_helper_psrlw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psrlw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psraw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psraw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psllw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psllw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psrld_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psrld_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psrad_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psrad_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pslld_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pslld_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psrlq_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psrlq_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psllq_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psllq_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }


static __attribute__ (( always_inline )) __inline__ void gen_helper_psrldq_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psrldq_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pslldq_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pslldq_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
# 63 "../../target-i386/ops_sse_header.h"
static __attribute__ (( always_inline )) __inline__ void gen_helper_paddb_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_paddb_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_paddw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_paddw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_paddl_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_paddl_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_paddq_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_paddq_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_psubb_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psubb_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psubw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psubw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psubl_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psubl_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psubq_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psubq_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_paddusb_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_paddusb_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_paddsb_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_paddsb_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psubusb_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psubusb_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psubsb_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psubsb_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_paddusw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_paddusw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_paddsw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_paddsw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psubusw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psubusw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psubsw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psubsw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_pminub_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pminub_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmaxub_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmaxub_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_pminsw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pminsw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmaxsw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmaxsw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_pand_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pand_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pandn_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pandn_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_por_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_por_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pxor_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pxor_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_pcmpgtb_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pcmpgtb_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pcmpgtw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pcmpgtw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pcmpgtl_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pcmpgtl_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_pcmpeqb_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pcmpeqb_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pcmpeqw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pcmpeqw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pcmpeql_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pcmpeql_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_pmullw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmullw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }



static __attribute__ (( always_inline )) __inline__ void gen_helper_pmulhuw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmulhuw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmulhw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmulhw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_pavgb_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pavgb_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pavgw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pavgw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_pmuludq_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmuludq_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmaddwd_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmaddwd_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_psadbw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psadbw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_maskmov_xmm( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i64 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 1 << (3*2); sizemask |= 0 << (3*2+1); tcg_gen_helperN(helper_maskmov_xmm, 0, sizemask, ((TCGArg)(-1)), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_movl_mm_T0_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_movl_mm_T0_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_movq_mm_T0_xmm( TCGv_i32 arg1, TCGv_i64 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 1 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_movq_mm_T0_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }





static __attribute__ (( always_inline )) __inline__ void gen_helper_shufps( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 1 << (3*2+1); tcg_gen_helperN(helper_shufps, 0, sizemask, ((TCGArg)(-1)), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_shufpd( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 1 << (3*2+1); tcg_gen_helperN(helper_shufpd, 0, sizemask, ((TCGArg)(-1)), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pshufd_xmm( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 1 << (3*2+1); tcg_gen_helperN(helper_pshufd_xmm, 0, sizemask, ((TCGArg)(-1)), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pshuflw_xmm( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 1 << (3*2+1); tcg_gen_helperN(helper_pshuflw_xmm, 0, sizemask, ((TCGArg)(-1)), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pshufhw_xmm( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 1 << (3*2+1); tcg_gen_helperN(helper_pshufhw_xmm, 0, sizemask, ((TCGArg)(-1)), 3, args); }
# 142 "../../target-i386/ops_sse_header.h"
static __attribute__ (( always_inline )) __inline__ void gen_helper_addps( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_addps, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_addss( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_addss, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_addpd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_addpd, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_addsd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_addsd, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_subps( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_subps, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_subss( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_subss, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_subpd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_subpd, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_subsd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_subsd, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_mulps( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_mulps, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_mulss( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_mulss, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_mulpd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_mulpd, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_mulsd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_mulsd, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_divps( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_divps, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_divss( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_divss, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_divpd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_divpd, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_divsd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_divsd, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_minps( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_minps, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_minss( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_minss, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_minpd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_minpd, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_minsd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_minsd, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_maxps( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_maxps, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_maxss( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_maxss, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_maxpd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_maxpd, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_maxsd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_maxsd, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_sqrtps( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_sqrtps, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_sqrtss( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_sqrtss, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_sqrtpd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_sqrtpd, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_sqrtsd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_sqrtsd, 0, sizemask, ((TCGArg)(-1)), 2, args); }


static __attribute__ (( always_inline )) __inline__ void gen_helper_cvtps2pd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cvtps2pd, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cvtpd2ps( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cvtpd2ps, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cvtss2sd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cvtss2sd, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cvtsd2ss( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cvtsd2ss, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cvtdq2ps( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cvtdq2ps, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cvtdq2pd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cvtdq2pd, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cvtpi2ps( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cvtpi2ps, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cvtpi2pd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cvtpi2pd, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cvtsi2ss( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cvtsi2ss, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cvtsi2sd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cvtsi2sd, 0, sizemask, ((TCGArg)(-1)), 2, args); }


static __attribute__ (( always_inline )) __inline__ void gen_helper_cvtsq2ss( TCGv_i32 arg1, TCGv_i64 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 1 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cvtsq2ss, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cvtsq2sd( TCGv_i32 arg1, TCGv_i64 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 1 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cvtsq2sd, 0, sizemask, ((TCGArg)(-1)), 2, args); }


static __attribute__ (( always_inline )) __inline__ void gen_helper_cvtps2dq( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cvtps2dq, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cvtpd2dq( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cvtpd2dq, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cvtps2pi( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cvtps2pi, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cvtpd2pi( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cvtpd2pi, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cvtss2si(TCGv_i32 retval, TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 1 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_cvtss2si, 0, sizemask, (retval), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cvtsd2si(TCGv_i32 retval, TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 1 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_cvtsd2si, 0, sizemask, (retval), 1, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_cvtss2sq(TCGv_i64 retval, TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 1 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_cvtss2sq, 0, sizemask, (retval), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cvtsd2sq(TCGv_i64 retval, TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 1 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_cvtsd2sq, 0, sizemask, (retval), 1, args); }


static __attribute__ (( always_inline )) __inline__ void gen_helper_cvttps2dq( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cvttps2dq, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cvttpd2dq( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cvttpd2dq, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cvttps2pi( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cvttps2pi, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cvttpd2pi( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cvttpd2pi, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cvttss2si(TCGv_i32 retval, TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 1 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_cvttss2si, 0, sizemask, (retval), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cvttsd2si(TCGv_i32 retval, TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 1 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_cvttsd2si, 0, sizemask, (retval), 1, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_cvttss2sq(TCGv_i64 retval, TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 1 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_cvttss2sq, 0, sizemask, (retval), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cvttsd2sq(TCGv_i64 retval, TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 1 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_cvttsd2sq, 0, sizemask, (retval), 1, args); }


static __attribute__ (( always_inline )) __inline__ void gen_helper_rsqrtps( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_rsqrtps, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_rsqrtss( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_rsqrtss, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_rcpps( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_rcpps, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_rcpss( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_rcpss, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_extrq_r( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_extrq_r, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_extrq_i( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 1 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 1 << (3*2+1); tcg_gen_helperN(helper_extrq_i, 0, sizemask, ((TCGArg)(-1)), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_insertq_r( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_insertq_r, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_insertq_i( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 1 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 1 << (3*2+1); tcg_gen_helperN(helper_insertq_i, 0, sizemask, ((TCGArg)(-1)), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_haddps( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_haddps, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_haddpd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_haddpd, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_hsubps( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_hsubps, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_hsubpd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_hsubpd, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_addsubps( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_addsubps, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_addsubpd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_addsubpd, 0, sizemask, ((TCGArg)(-1)), 2, args); }







static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpeqps( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpeqps, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpeqss( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpeqss, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpeqpd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpeqpd, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpeqsd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpeqsd, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpltps( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpltps, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpltss( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpltss, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpltpd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpltpd, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpltsd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpltsd, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpleps( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpleps, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpless( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpless, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmplepd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmplepd, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmplesd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmplesd, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpunordps( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpunordps, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpunordss( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpunordss, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpunordpd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpunordpd, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpunordsd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpunordsd, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpneqps( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpneqps, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpneqss( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpneqss, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpneqpd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpneqpd, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpneqsd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpneqsd, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpnltps( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpnltps, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpnltss( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpnltss, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpnltpd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpnltpd, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpnltsd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpnltsd, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpnleps( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpnleps, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpnless( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpnless, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpnlepd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpnlepd, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpnlesd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpnlesd, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpordps( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpordps, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpordss( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpordss, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpordpd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpordpd, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_cmpordsd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_cmpordsd, 0, sizemask, ((TCGArg)(-1)), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_ucomiss( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_ucomiss, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_comiss( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_comiss, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_ucomisd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_ucomisd, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_comisd( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_comisd, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_movmskps(TCGv_i32 retval, TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_movmskps, 0, sizemask, (retval), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_movmskpd(TCGv_i32 retval, TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_movmskpd, 0, sizemask, (retval), 1, args); }


static __attribute__ (( always_inline )) __inline__ void gen_helper_pmovmskb_xmm(TCGv_i32 retval, TCGv_i32 arg1) { TCGArg args[1]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); tcg_gen_helperN(helper_pmovmskb_xmm, 0, sizemask, (retval), 1, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_packsswb_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_packsswb_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_packuswb_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_packuswb_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_packssdw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_packssdw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }





static __attribute__ (( always_inline )) __inline__ void gen_helper_punpcklbw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_punpcklbw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_punpcklwd_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_punpcklwd_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_punpckldq_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_punpckldq_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_punpckhbw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_punpckhbw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_punpckhwd_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_punpckhwd_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); } static __attribute__ (( always_inline )) __inline__ void gen_helper_punpckhdq_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_punpckhdq_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }


static __attribute__ (( always_inline )) __inline__ void gen_helper_punpcklqdq_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_punpcklqdq_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_punpckhqdq_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_punpckhqdq_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
# 268 "../../target-i386/ops_sse_header.h"
static __attribute__ (( always_inline )) __inline__ void gen_helper_phaddw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_phaddw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_phaddd_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_phaddd_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_phaddsw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_phaddsw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_phsubw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_phsubw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_phsubd_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_phsubd_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_phsubsw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_phsubsw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pabsb_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pabsb_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pabsw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pabsw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pabsd_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pabsd_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmaddubsw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmaddubsw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmulhrsw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmulhrsw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pshufb_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pshufb_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psignb_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psignb_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psignw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psignw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_psignd_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_psignd_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_palignr_xmm( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 1 << (3*2+1); tcg_gen_helperN(helper_palignr_xmm, 0, sizemask, ((TCGArg)(-1)), 3, args); }



static __attribute__ (( always_inline )) __inline__ void gen_helper_pblendvb_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pblendvb_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_blendvps_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_blendvps_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_blendvpd_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_blendvpd_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_ptest_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_ptest_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmovsxbw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmovsxbw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmovsxbd_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmovsxbd_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmovsxbq_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmovsxbq_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmovsxwd_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmovsxwd_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmovsxwq_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmovsxwq_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmovsxdq_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmovsxdq_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmovzxbw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmovzxbw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmovzxbd_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmovzxbd_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmovzxbq_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmovzxbq_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmovzxwd_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmovzxwd_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmovzxwq_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmovzxwq_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmovzxdq_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmovzxdq_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmuldq_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmuldq_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pcmpeqq_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pcmpeqq_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_packusdw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_packusdw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pminsb_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pminsb_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pminsd_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pminsd_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pminuw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pminuw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pminud_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pminud_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmaxsb_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmaxsb_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmaxsd_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmaxsd_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmaxuw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmaxuw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmaxud_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmaxud_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pmulld_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pmulld_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_phminposuw_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_phminposuw_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_roundps_xmm( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 0 << (3*2+1); tcg_gen_helperN(helper_roundps_xmm, 0, sizemask, ((TCGArg)(-1)), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_roundpd_xmm( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 0 << (3*2+1); tcg_gen_helperN(helper_roundpd_xmm, 0, sizemask, ((TCGArg)(-1)), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_roundss_xmm( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 0 << (3*2+1); tcg_gen_helperN(helper_roundss_xmm, 0, sizemask, ((TCGArg)(-1)), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_roundsd_xmm( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 0 << (3*2+1); tcg_gen_helperN(helper_roundsd_xmm, 0, sizemask, ((TCGArg)(-1)), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_blendps_xmm( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 0 << (3*2+1); tcg_gen_helperN(helper_blendps_xmm, 0, sizemask, ((TCGArg)(-1)), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_blendpd_xmm( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 0 << (3*2+1); tcg_gen_helperN(helper_blendpd_xmm, 0, sizemask, ((TCGArg)(-1)), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pblendw_xmm( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 0 << (3*2+1); tcg_gen_helperN(helper_pblendw_xmm, 0, sizemask, ((TCGArg)(-1)), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_dpps_xmm( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 0 << (3*2+1); tcg_gen_helperN(helper_dpps_xmm, 0, sizemask, ((TCGArg)(-1)), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_dppd_xmm( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 0 << (3*2+1); tcg_gen_helperN(helper_dppd_xmm, 0, sizemask, ((TCGArg)(-1)), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_mpsadbw_xmm( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 0 << (3*2+1); tcg_gen_helperN(helper_mpsadbw_xmm, 0, sizemask, ((TCGArg)(-1)), 3, args); }




static __attribute__ (( always_inline )) __inline__ void gen_helper_pcmpgtq_xmm( TCGv_i32 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_pcmpgtq_xmm, 0, sizemask, ((TCGArg)(-1)), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pcmpestri_xmm( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 0 << (3*2+1); tcg_gen_helperN(helper_pcmpestri_xmm, 0, sizemask, ((TCGArg)(-1)), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pcmpestrm_xmm( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 0 << (3*2+1); tcg_gen_helperN(helper_pcmpestrm_xmm, 0, sizemask, ((TCGArg)(-1)), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pcmpistri_xmm( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 0 << (3*2+1); tcg_gen_helperN(helper_pcmpistri_xmm, 0, sizemask, ((TCGArg)(-1)), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_pcmpistrm_xmm( TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 0 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= (32 == 64) << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= (32 == 64) << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 0 << (3*2+1); tcg_gen_helperN(helper_pcmpistrm_xmm, 0, sizemask, ((TCGArg)(-1)), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_crc32(TCGv_i64 retval, TCGv_i32 arg1, TCGv_i64 arg2, TCGv_i32 arg3) { TCGArg args[3]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 0 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 1 << (2*2); sizemask |= 0 << (2*2+1); args[3 - 1] = (arg3); sizemask |= 0 << (3*2); sizemask |= 0 << (3*2+1); tcg_gen_helperN(helper_crc32, 0, sizemask, (retval), 3, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_popcnt(TCGv_i64 retval, TCGv_i64 arg1, TCGv_i32 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 0 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_popcnt, 0, sizemask, (retval), 2, args); }
# 208 "../../target-i386/helper.h" 2

static __attribute__ (( always_inline )) __inline__ void gen_helper_rclb(TCGv_i64 retval, TCGv_i64 arg1, TCGv_i64 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 1 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_rclb, 0, sizemask, (retval), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_rclw(TCGv_i64 retval, TCGv_i64 arg1, TCGv_i64 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 1 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_rclw, 0, sizemask, (retval), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_rcll(TCGv_i64 retval, TCGv_i64 arg1, TCGv_i64 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 1 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_rcll, 0, sizemask, (retval), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_rcrb(TCGv_i64 retval, TCGv_i64 arg1, TCGv_i64 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 1 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_rcrb, 0, sizemask, (retval), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_rcrw(TCGv_i64 retval, TCGv_i64 arg1, TCGv_i64 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 1 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_rcrw, 0, sizemask, (retval), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_rcrl(TCGv_i64 retval, TCGv_i64 arg1, TCGv_i64 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 1 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_rcrl, 0, sizemask, (retval), 2, args); }

static __attribute__ (( always_inline )) __inline__ void gen_helper_rclq(TCGv_i64 retval, TCGv_i64 arg1, TCGv_i64 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 1 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_rclq, 0, sizemask, (retval), 2, args); }
static __attribute__ (( always_inline )) __inline__ void gen_helper_rcrq(TCGv_i64 retval, TCGv_i64 arg1, TCGv_i64 arg2) { TCGArg args[2]; int sizemask = 0; sizemask |= 1 << (0*2); sizemask |= 0 << (0*2+1); args[1 - 1] = (arg1); sizemask |= 1 << (1*2); sizemask |= 0 << (1*2+1); args[2 - 1] = (arg2); sizemask |= 1 << (2*2); sizemask |= 0 << (2*2+1); tcg_gen_helperN(helper_rcrq, 0, sizemask, (retval), 2, args); }


# 1 "../../def-helper.h" 1
# 220 "../../target-i386/helper.h" 2
# 34 "../../target-i386/translate.c" 2
# 62 "../../target-i386/translate.c"
static TCGv_i32 cpu_env;
static TCGv_i64 cpu_A0, cpu_cc_src, cpu_cc_dst, cpu_cc_tmp;
static TCGv_i32 cpu_cc_op;
static TCGv_i64 cpu_regs[16];

static TCGv_i64 cpu_T[2], cpu_T3;

static TCGv_i64 cpu_tmp0, cpu_tmp4;
static TCGv_i32 cpu_ptr0, cpu_ptr1;
static TCGv_i32 cpu_tmp2_i32, cpu_tmp3_i32;
static TCGv_i64 cpu_tmp1_i64;
static TCGv_i64 cpu_tmp5;

static uint8_t gen_opc_cc_op[640];

# 1 "../../gen-icount.h" 1
# 1 "../../qemu-timer.h" 1
# 15 "../../qemu-timer.h"
typedef struct QEMUClock QEMUClock;
typedef void QEMUTimerCB(void *opaque);





extern QEMUClock *rt_clock;




extern QEMUClock *vm_clock;






extern QEMUClock *host_clock;

int64_t qemu_get_clock(QEMUClock *clock);
int64_t qemu_get_clock_ns(QEMUClock *clock);
void qemu_clock_enable(QEMUClock *clock, int enabled);

QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque);
void qemu_free_timer(QEMUTimer *ts);
void qemu_del_timer(QEMUTimer *ts);
void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
int qemu_timer_pending(QEMUTimer *ts);
int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time);

void qemu_run_all_timers(void);
int qemu_alarm_pending(void);
int64_t qemu_next_deadline(void);
void configure_alarms(char const *opt);
void configure_icount(const char *option);
int qemu_calculate_timeout(void);
void init_clocks(void);
int init_timer_alarm(void);
void quit_timers(void);

static __attribute__ (( always_inline )) __inline__ int64_t get_ticks_per_sec(void)
{
    return 1000000000LL;
}


static __attribute__ (( always_inline )) __inline__ int64_t get_clock_realtime(void)
{
    struct timeval tv;

    gettimeofday(&tv, ((void *)0));
    return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
}
# 86 "../../qemu-timer.h"
extern int use_rt_clock;

static __attribute__ (( always_inline )) __inline__ int64_t get_clock(void)
{


    if (use_rt_clock) {
        struct timespec ts;
        clock_gettime(1, &ts);
        return ts.tv_sec * 1000000000LL + ts.tv_nsec;
    } else

    {


        return get_clock_realtime();
    }
}


void qemu_get_timer(QEMUFile *f, QEMUTimer *ts);
void qemu_put_timer(QEMUFile *f, QEMUTimer *ts);


typedef struct ptimer_state ptimer_state;
typedef void (*ptimer_cb)(void *opaque);

ptimer_state *ptimer_init(QEMUBH *bh);
void ptimer_set_period(ptimer_state *s, int64_t period);
void ptimer_set_freq(ptimer_state *s, uint32_t freq);
void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload);
uint64_t ptimer_get_count(ptimer_state *s);
void ptimer_set_count(ptimer_state *s, uint64_t count);
void ptimer_run(ptimer_state *s, int oneshot);
void ptimer_stop(ptimer_state *s);
void qemu_put_ptimer(QEMUFile *f, ptimer_state *s);
void qemu_get_ptimer(QEMUFile *f, ptimer_state *s);


int64_t qemu_icount_round(int64_t count);
extern int64_t qemu_icount;
extern int use_icount;
extern int icount_time_shift;
extern int64_t qemu_icount_bias;
int64_t cpu_get_icount(void);
# 279 "../../qemu-timer.h"
static __attribute__ (( always_inline )) __inline__ int64_t cpu_get_real_ticks (void)
{
    static int64_t ticks = 0;
    return ticks++;
}





static __attribute__ (( always_inline )) __inline__ int can_do_io(struct CPUX86State *env)
{
    if (!use_icount)
        return 1;


    if (!env->current_tb)
        return 1;

    return env->can_do_io != 0;
}
# 2 "../../gen-icount.h" 2



static TCGArg *icount_arg;
static int icount_label;

static __attribute__ (( always_inline )) __inline__ void gen_icount_start(void)
{
    TCGv_i32 count;

    if (!use_icount)
        return;

    icount_label = gen_new_label();
    count = tcg_temp_local_new_i32();
    tcg_gen_ld_i32(count, cpu_env, __builtin_offsetof (struct CPUX86State, icount_decr.u32));

    icount_arg = gen_opparam_ptr + 1;
    tcg_gen_subi_i32(count, count, 0xdeadbeef);

    tcg_gen_brcondi_i32(TCG_COND_LT, count, 0, icount_label);
    tcg_gen_st16_i32(count, cpu_env, __builtin_offsetof (struct CPUX86State, icount_decr.u16.low));
    tcg_temp_free_i32(count);
}

static void gen_icount_end(TranslationBlock *tb, int num_insns)
{
    if (use_icount) {
        *icount_arg = num_insns;
        gen_set_label(icount_label);
        tcg_gen_exit_tb((long)tb + 2);
    }
}

static __attribute__ (( always_inline )) __inline__ void gen_io_start(void)
{
    TCGv_i32 tmp = tcg_const_i32(1);
    tcg_gen_st_i32(tmp, cpu_env, __builtin_offsetof (struct CPUX86State, can_do_io));
    tcg_temp_free_i32(tmp);
}

static __attribute__ (( always_inline )) __inline__ void gen_io_end(void)
{
    TCGv_i32 tmp = tcg_const_i32(0);
    tcg_gen_st_i32(tmp, cpu_env, __builtin_offsetof (struct CPUX86State, can_do_io));
    tcg_temp_free_i32(tmp);
}
# 78 "../../target-i386/translate.c" 2


static int x86_64_hregs;


typedef struct DisasContext {

    int override;
    int prefix;
    int aflag, dflag;
    target_ulong pc;
    int is_jmp;


    target_ulong cs_base;
    int pe;
    int code32;

    int lma;
    int code64;
    int rex_x, rex_b;

    int ss32;
    int cc_op;
    int addseg;
    int f_st;
    int vm86;
    int cpl;
    int iopl;
    int tf;
    int singlestep_enabled;
    int jmp_opt;
    int mem_index;
    uint64_t flags;
    struct TranslationBlock *tb;
    int popl_esp_hack;
    int rip_offset;
    int cpuid_features;
    int cpuid_ext_features;
    int cpuid_ext2_features;
    int cpuid_ext3_features;
} DisasContext;

static void gen_eob(DisasContext *s);
static void gen_jmp(DisasContext *s, target_ulong eip);
static void gen_jmp_tb(DisasContext *s, target_ulong eip, int tb_num);


enum {
    OP_ADDL,
    OP_ORL,
    OP_ADCL,
    OP_SBBL,
    OP_ANDL,
    OP_SUBL,
    OP_XORL,
    OP_CMPL,
};


enum {
    OP_ROL,
    OP_ROR,
    OP_RCL,
    OP_RCR,
    OP_SHL,
    OP_SHR,
    OP_SHL1,
    OP_SAR = 7,
};

enum {
    JCC_O,
    JCC_B,
    JCC_Z,
    JCC_BE,
    JCC_S,
    JCC_P,
    JCC_L,
    JCC_LE,
};


enum {
    OT_BYTE = 0,
    OT_WORD,
    OT_LONG,
    OT_QUAD,
};

enum {

    OR_EAX,
    OR_ECX,
    OR_EDX,
    OR_EBX,
    OR_ESP,
    OR_EBP,
    OR_ESI,
    OR_EDI,

    OR_TMP0 = 16,
    OR_TMP1,
    OR_A0,
};

static __attribute__ (( always_inline )) __inline__ void gen_op_movl_T0_0(void)
{
    tcg_gen_movi_i64(cpu_T[0], 0);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_movl_T0_im(int32_t val)
{
    tcg_gen_movi_i64(cpu_T[0], val);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_movl_T0_imu(uint32_t val)
{
    tcg_gen_movi_i64(cpu_T[0], val);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_movl_T1_im(int32_t val)
{
    tcg_gen_movi_i64(cpu_T[1], val);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_movl_T1_imu(uint32_t val)
{
    tcg_gen_movi_i64(cpu_T[1], val);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_movl_A0_im(uint32_t val)
{
    tcg_gen_movi_i64(cpu_A0, val);
}


static __attribute__ (( always_inline )) __inline__ void gen_op_movq_A0_im(int64_t val)
{
    tcg_gen_movi_i64(cpu_A0, val);
}


static __attribute__ (( always_inline )) __inline__ void gen_movtl_T0_im(target_ulong val)
{
    tcg_gen_movi_i64(cpu_T[0], val);
}

static __attribute__ (( always_inline )) __inline__ void gen_movtl_T1_im(target_ulong val)
{
    tcg_gen_movi_i64(cpu_T[1], val);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_andl_T0_ffff(void)
{
    tcg_gen_andi_i64(cpu_T[0], cpu_T[0], 0xffff);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_andl_T0_im(uint32_t val)
{
    tcg_gen_andi_i64(cpu_T[0], cpu_T[0], val);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_movl_T0_T1(void)
{
    tcg_gen_mov_i64(cpu_T[0], cpu_T[1]);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_andl_A0_ffff(void)
{
    tcg_gen_andi_i64(cpu_A0, cpu_A0, 0xffff);
}
# 275 "../../target-i386/translate.c"
static __attribute__ (( always_inline )) __inline__ void gen_op_mov_reg_v(int ot, int reg, TCGv_i64 t0)
{
    switch(ot) {
    case OT_BYTE:
        if (reg < 4 || reg >= 8 || x86_64_hregs) {
            tcg_gen_deposit_i64(cpu_regs[reg], cpu_regs[reg], t0, 0, 8);
        } else {
            tcg_gen_deposit_i64(cpu_regs[reg - 4], cpu_regs[reg - 4], t0, 8, 8);
        }
        break;
    case OT_WORD:
        tcg_gen_deposit_i64(cpu_regs[reg], cpu_regs[reg], t0, 0, 16);
        break;
    default:
    case OT_LONG:


        tcg_gen_ext32u_i64(cpu_regs[reg], t0);
        break;

    case OT_QUAD:
        tcg_gen_mov_i64(cpu_regs[reg], t0);
        break;

    }
}

static __attribute__ (( always_inline )) __inline__ void gen_op_mov_reg_T0(int ot, int reg)
{
    gen_op_mov_reg_v(ot, reg, cpu_T[0]);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_mov_reg_T1(int ot, int reg)
{
    gen_op_mov_reg_v(ot, reg, cpu_T[1]);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_mov_reg_A0(int size, int reg)
{
    switch(size) {
    case 0:
        tcg_gen_deposit_i64(cpu_regs[reg], cpu_regs[reg], cpu_A0, 0, 16);
        break;
    default:
    case 1:


        tcg_gen_ext32u_i64(cpu_regs[reg], cpu_A0);
        break;

    case 2:
        tcg_gen_mov_i64(cpu_regs[reg], cpu_A0);
        break;

    }
}

static __attribute__ (( always_inline )) __inline__ void gen_op_mov_v_reg(int ot, TCGv_i64 t0, int reg)
{
    switch(ot) {
    case OT_BYTE:
        if (reg < 4 || reg >= 8 || x86_64_hregs) {
            goto std_case;
        } else {
            tcg_gen_shri_i64(t0, cpu_regs[reg - 4], 8);
            tcg_gen_ext8u_i64(t0, t0);
        }
        break;
    default:
    std_case:
        tcg_gen_mov_i64(t0, cpu_regs[reg]);
        break;
    }
}

static __attribute__ (( always_inline )) __inline__ void gen_op_mov_TN_reg(int ot, int t_index, int reg)
{
    gen_op_mov_v_reg(ot, cpu_T[t_index], reg);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_movl_A0_reg(int reg)
{
    tcg_gen_mov_i64(cpu_A0, cpu_regs[reg]);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_addl_A0_im(int32_t val)
{
    tcg_gen_addi_i64(cpu_A0, cpu_A0, val);

    tcg_gen_andi_i64(cpu_A0, cpu_A0, 0xffffffff);

}


static __attribute__ (( always_inline )) __inline__ void gen_op_addq_A0_im(int64_t val)
{
    tcg_gen_addi_i64(cpu_A0, cpu_A0, val);
}


static void gen_add_A0_im(DisasContext *s, int val)
{

    if (((s)->code64))
        gen_op_addq_A0_im(val);
    else

        gen_op_addl_A0_im(val);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_addl_T0_T1(void)
{
    tcg_gen_add_i64(cpu_T[0], cpu_T[0], cpu_T[1]);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_jmp_T0(void)
{
    tcg_gen_st_i64(cpu_T[0], cpu_env, __builtin_offsetof (struct CPUX86State, eip));
}

static __attribute__ (( always_inline )) __inline__ void gen_op_add_reg_im(int size, int reg, int32_t val)
{
    switch(size) {
    case 0:
        tcg_gen_addi_i64(cpu_tmp0, cpu_regs[reg], val);
        tcg_gen_deposit_i64(cpu_regs[reg], cpu_regs[reg], cpu_tmp0, 0, 16);
        break;
    case 1:
        tcg_gen_addi_i64(cpu_tmp0, cpu_regs[reg], val);


        tcg_gen_ext32u_i64(cpu_tmp0, cpu_tmp0);
        tcg_gen_mov_i64(cpu_regs[reg], cpu_tmp0);
        break;

    case 2:
        tcg_gen_addi_i64(cpu_regs[reg], cpu_regs[reg], val);
        break;

    }
}

static __attribute__ (( always_inline )) __inline__ void gen_op_add_reg_T0(int size, int reg)
{
    switch(size) {
    case 0:
        tcg_gen_add_i64(cpu_tmp0, cpu_regs[reg], cpu_T[0]);
        tcg_gen_deposit_i64(cpu_regs[reg], cpu_regs[reg], cpu_tmp0, 0, 16);
        break;
    case 1:
        tcg_gen_add_i64(cpu_tmp0, cpu_regs[reg], cpu_T[0]);


        tcg_gen_ext32u_i64(cpu_tmp0, cpu_tmp0);
        tcg_gen_mov_i64(cpu_regs[reg], cpu_tmp0);
        break;

    case 2:
        tcg_gen_add_i64(cpu_regs[reg], cpu_regs[reg], cpu_T[0]);
        break;

    }
}

static __attribute__ (( always_inline )) __inline__ void gen_op_set_cc_op(int32_t val)
{
    tcg_gen_movi_i32(cpu_cc_op, val);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_addl_A0_reg_sN(int shift, int reg)
{
    tcg_gen_mov_i64(cpu_tmp0, cpu_regs[reg]);
    if (shift != 0)
        tcg_gen_shli_i64(cpu_tmp0, cpu_tmp0, shift);
    tcg_gen_add_i64(cpu_A0, cpu_A0, cpu_tmp0);


    tcg_gen_ext32u_i64(cpu_A0, cpu_A0);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_movl_A0_seg(int reg)
{
    tcg_gen_ld32u_i64(cpu_A0, cpu_env, __builtin_offsetof (struct CPUX86State, segs[reg].base) + 0);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_addl_A0_seg(int reg)
{
    tcg_gen_ld_i64(cpu_tmp0, cpu_env, __builtin_offsetof (struct CPUX86State, segs[reg].base));
    tcg_gen_add_i64(cpu_A0, cpu_A0, cpu_tmp0);

    tcg_gen_andi_i64(cpu_A0, cpu_A0, 0xffffffff);

}


static __attribute__ (( always_inline )) __inline__ void gen_op_movq_A0_seg(int reg)
{
    tcg_gen_ld_i64(cpu_A0, cpu_env, __builtin_offsetof (struct CPUX86State, segs[reg].base));
}

static __attribute__ (( always_inline )) __inline__ void gen_op_addq_A0_seg(int reg)
{
    tcg_gen_ld_i64(cpu_tmp0, cpu_env, __builtin_offsetof (struct CPUX86State, segs[reg].base));
    tcg_gen_add_i64(cpu_A0, cpu_A0, cpu_tmp0);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_movq_A0_reg(int reg)
{
    tcg_gen_mov_i64(cpu_A0, cpu_regs[reg]);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_addq_A0_reg_sN(int shift, int reg)
{
    tcg_gen_mov_i64(cpu_tmp0, cpu_regs[reg]);
    if (shift != 0)
        tcg_gen_shli_i64(cpu_tmp0, cpu_tmp0, shift);
    tcg_gen_add_i64(cpu_A0, cpu_A0, cpu_tmp0);
}


static __attribute__ (( always_inline )) __inline__ void gen_op_lds_T0_A0(int idx)
{
    int mem_index = (idx >> 2) - 1;
    switch(idx & 3) {
    case 0:
        tcg_gen_qemu_ld8s(cpu_T[0], cpu_A0, mem_index);
        break;
    case 1:
        tcg_gen_qemu_ld16s(cpu_T[0], cpu_A0, mem_index);
        break;
    default:
    case 2:
        tcg_gen_qemu_ld32s(cpu_T[0], cpu_A0, mem_index);
        break;
    }
}

static __attribute__ (( always_inline )) __inline__ void gen_op_ld_v(int idx, TCGv_i64 t0, TCGv_i64 a0)
{
    int mem_index = (idx >> 2) - 1;
    switch(idx & 3) {
    case 0:
        tcg_gen_qemu_ld8u(t0, a0, mem_index);
        break;
    case 1:
        tcg_gen_qemu_ld16u(t0, a0, mem_index);
        break;
    case 2:
        tcg_gen_qemu_ld32u(t0, a0, mem_index);
        break;
    default:
    case 3:


        tcg_gen_qemu_ld64(t0, a0, mem_index);

        break;
    }
}


static __attribute__ (( always_inline )) __inline__ void gen_op_ld_T0_A0(int idx)
{
    gen_op_ld_v(idx, cpu_T[0], cpu_A0);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_ldu_T0_A0(int idx)
{
    gen_op_ld_v(idx, cpu_T[0], cpu_A0);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_ld_T1_A0(int idx)
{
    gen_op_ld_v(idx, cpu_T[1], cpu_A0);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_st_v(int idx, TCGv_i64 t0, TCGv_i64 a0)
{
    int mem_index = (idx >> 2) - 1;
    switch(idx & 3) {
    case 0:
        tcg_gen_qemu_st8(t0, a0, mem_index);
        break;
    case 1:
        tcg_gen_qemu_st16(t0, a0, mem_index);
        break;
    case 2:
        tcg_gen_qemu_st32(t0, a0, mem_index);
        break;
    default:
    case 3:


        tcg_gen_qemu_st64(t0, a0, mem_index);

        break;
    }
}

static __attribute__ (( always_inline )) __inline__ void gen_op_st_T0_A0(int idx)
{
    gen_op_st_v(idx, cpu_T[0], cpu_A0);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_st_T1_A0(int idx)
{
    gen_op_st_v(idx, cpu_T[1], cpu_A0);
}

static __attribute__ (( always_inline )) __inline__ void gen_jmp_im(target_ulong pc)
{
    tcg_gen_movi_i64(cpu_tmp0, pc);
    tcg_gen_st_i64(cpu_tmp0, cpu_env, __builtin_offsetof (struct CPUX86State, eip));
}

static __attribute__ (( always_inline )) __inline__ void gen_string_movl_A0_ESI(DisasContext *s)
{
    int override;

    override = s->override;

    if (s->aflag == 2) {
        if (override >= 0) {
            gen_op_movq_A0_seg(override);
            gen_op_addq_A0_reg_sN(0, 6);
        } else {
            gen_op_movq_A0_reg(6);
        }
    } else

    if (s->aflag) {

        if (s->addseg && override < 0)
            override = 3;
        if (override >= 0) {
            gen_op_movl_A0_seg(override);
            gen_op_addl_A0_reg_sN(0, 6);
        } else {
            gen_op_movl_A0_reg(6);
        }
    } else {

        if (override < 0)
            override = 3;
        gen_op_movl_A0_reg(6);
        gen_op_andl_A0_ffff();
        gen_op_addl_A0_seg(override);
    }
}

static __attribute__ (( always_inline )) __inline__ void gen_string_movl_A0_EDI(DisasContext *s)
{

    if (s->aflag == 2) {
        gen_op_movq_A0_reg(7);
    } else

    if (s->aflag) {
        if (s->addseg) {
            gen_op_movl_A0_seg(0);
            gen_op_addl_A0_reg_sN(0, 7);
        } else {
            gen_op_movl_A0_reg(7);
        }
    } else {
        gen_op_movl_A0_reg(7);
        gen_op_andl_A0_ffff();
        gen_op_addl_A0_seg(0);
    }
}

static __attribute__ (( always_inline )) __inline__ void gen_op_movl_T0_Dshift(int ot)
{
    tcg_gen_ld32s_i64(cpu_T[0], cpu_env, __builtin_offsetof (struct CPUX86State, df));
    tcg_gen_shli_i64(cpu_T[0], cpu_T[0], ot);
};

static void gen_extu(int ot, TCGv_i64 reg)
{
    switch(ot) {
    case OT_BYTE:
        tcg_gen_ext8u_i64(reg, reg);
        break;
    case OT_WORD:
        tcg_gen_ext16u_i64(reg, reg);
        break;
    case OT_LONG:
        tcg_gen_ext32u_i64(reg, reg);
        break;
    default:
        break;
    }
}

static void gen_exts(int ot, TCGv_i64 reg)
{
    switch(ot) {
    case OT_BYTE:
        tcg_gen_ext8s_i64(reg, reg);
        break;
    case OT_WORD:
        tcg_gen_ext16s_i64(reg, reg);
        break;
    case OT_LONG:
        tcg_gen_ext32s_i64(reg, reg);
        break;
    default:
        break;
    }
}

static __attribute__ (( always_inline )) __inline__ void gen_op_jnz_ecx(int size, int label1)
{
    tcg_gen_mov_i64(cpu_tmp0, cpu_regs[1]);
    gen_extu(size + 1, cpu_tmp0);
    tcg_gen_brcondi_i64(TCG_COND_NE, cpu_tmp0, 0, label1);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_jz_ecx(int size, int label1)
{
    tcg_gen_mov_i64(cpu_tmp0, cpu_regs[1]);
    gen_extu(size + 1, cpu_tmp0);
    tcg_gen_brcondi_i64(TCG_COND_EQ, cpu_tmp0, 0, label1);
}

static void gen_helper_in_func(int ot, TCGv_i64 v, TCGv_i32 n)
{
    switch (ot) {
    case 0: gen_helper_inb(v, n); break;
    case 1: gen_helper_inw(v, n); break;
    case 2: gen_helper_inl(v, n); break;
    }

}

static void gen_helper_out_func(int ot, TCGv_i32 v, TCGv_i32 n)
{
    switch (ot) {
    case 0: gen_helper_outb(v, n); break;
    case 1: gen_helper_outw(v, n); break;
    case 2: gen_helper_outl(v, n); break;
    }

}

static void gen_check_io(DisasContext *s, int ot, target_ulong cur_eip,
                         uint32_t svm_flags)
{
    int state_saved;
    target_ulong next_eip;

    state_saved = 0;
    if (s->pe && (s->cpl > s->iopl || s->vm86)) {
        if (s->cc_op != CC_OP_DYNAMIC)
            gen_op_set_cc_op(s->cc_op);
        gen_jmp_im(cur_eip);
        state_saved = 1;
        tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
        switch (ot) {
        case 0: gen_helper_check_iob(cpu_tmp2_i32); break;
        case 1: gen_helper_check_iow(cpu_tmp2_i32); break;
        case 2: gen_helper_check_iol(cpu_tmp2_i32); break;
        }
    }
    if(s->flags & (1 << 21)) {
        if (!state_saved) {
            if (s->cc_op != CC_OP_DYNAMIC)
                gen_op_set_cc_op(s->cc_op);
            gen_jmp_im(cur_eip);
        }
        svm_flags |= (1 << (4 + ot));
        next_eip = s->pc - s->cs_base;
        tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
        gen_helper_svm_check_io(cpu_tmp2_i32, tcg_const_i32(svm_flags),
                                tcg_const_i32(next_eip - cur_eip));
    }
}

static __attribute__ (( always_inline )) __inline__ void gen_movs(DisasContext *s, int ot)
{
    gen_string_movl_A0_ESI(s);
    gen_op_ld_T0_A0(ot + s->mem_index);
    gen_string_movl_A0_EDI(s);
    gen_op_st_T0_A0(ot + s->mem_index);
    gen_op_movl_T0_Dshift(ot);
    gen_op_add_reg_T0(s->aflag, 6);
    gen_op_add_reg_T0(s->aflag, 7);
}

static __attribute__ (( always_inline )) __inline__ void gen_update_cc_op(DisasContext *s)
{
    if (s->cc_op != CC_OP_DYNAMIC) {
        gen_op_set_cc_op(s->cc_op);
        s->cc_op = CC_OP_DYNAMIC;
    }
}

static void gen_op_update1_cc(void)
{
    tcg_gen_discard_i64(cpu_cc_src);
    tcg_gen_mov_i64(cpu_cc_dst, cpu_T[0]);
}

static void gen_op_update2_cc(void)
{
    tcg_gen_mov_i64(cpu_cc_src, cpu_T[1]);
    tcg_gen_mov_i64(cpu_cc_dst, cpu_T[0]);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_cmpl_T0_T1_cc(void)
{
    tcg_gen_mov_i64(cpu_cc_src, cpu_T[1]);
    tcg_gen_sub_i64(cpu_cc_dst, cpu_T[0], cpu_T[1]);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_testl_T0_T1_cc(void)
{
    tcg_gen_discard_i64(cpu_cc_src);
    tcg_gen_and_i64(cpu_cc_dst, cpu_T[0], cpu_T[1]);
}

static void gen_op_update_neg_cc(void)
{
    tcg_gen_neg_i64(cpu_cc_src, cpu_T[0]);
    tcg_gen_mov_i64(cpu_cc_dst, cpu_T[0]);
}


static void gen_compute_eflags_c(TCGv_i64 reg)
{
    gen_helper_cc_compute_c(cpu_tmp2_i32, cpu_cc_op);
    tcg_gen_extu_i32_i64(reg, cpu_tmp2_i32);
}


static void gen_compute_eflags(TCGv_i64 reg)
{
    gen_helper_cc_compute_all(cpu_tmp2_i32, cpu_cc_op);
    tcg_gen_extu_i32_i64(reg, cpu_tmp2_i32);
}

static __attribute__ (( always_inline )) __inline__ void gen_setcc_slow_T0(DisasContext *s, int jcc_op)
{
    if (s->cc_op != CC_OP_DYNAMIC)
        gen_op_set_cc_op(s->cc_op);
    switch(jcc_op) {
    case JCC_O:
        gen_compute_eflags(cpu_T[0]);
        tcg_gen_shri_i64(cpu_T[0], cpu_T[0], 11);
        tcg_gen_andi_i64(cpu_T[0], cpu_T[0], 1);
        break;
    case JCC_B:
        gen_compute_eflags_c(cpu_T[0]);
        break;
    case JCC_Z:
        gen_compute_eflags(cpu_T[0]);
        tcg_gen_shri_i64(cpu_T[0], cpu_T[0], 6);
        tcg_gen_andi_i64(cpu_T[0], cpu_T[0], 1);
        break;
    case JCC_BE:
        gen_compute_eflags(cpu_tmp0);
        tcg_gen_shri_i64(cpu_T[0], cpu_tmp0, 6);
        tcg_gen_or_i64(cpu_T[0], cpu_T[0], cpu_tmp0);
        tcg_gen_andi_i64(cpu_T[0], cpu_T[0], 1);
        break;
    case JCC_S:
        gen_compute_eflags(cpu_T[0]);
        tcg_gen_shri_i64(cpu_T[0], cpu_T[0], 7);
        tcg_gen_andi_i64(cpu_T[0], cpu_T[0], 1);
        break;
    case JCC_P:
        gen_compute_eflags(cpu_T[0]);
        tcg_gen_shri_i64(cpu_T[0], cpu_T[0], 2);
        tcg_gen_andi_i64(cpu_T[0], cpu_T[0], 1);
        break;
    case JCC_L:
        gen_compute_eflags(cpu_tmp0);
        tcg_gen_shri_i64(cpu_T[0], cpu_tmp0, 11);
        tcg_gen_shri_i64(cpu_tmp0, cpu_tmp0, 7);
        tcg_gen_xor_i64(cpu_T[0], cpu_T[0], cpu_tmp0);
        tcg_gen_andi_i64(cpu_T[0], cpu_T[0], 1);
        break;
    default:
    case JCC_LE:
        gen_compute_eflags(cpu_tmp0);
        tcg_gen_shri_i64(cpu_T[0], cpu_tmp0, 11);
        tcg_gen_shri_i64(cpu_tmp4, cpu_tmp0, 7);
        tcg_gen_shri_i64(cpu_tmp0, cpu_tmp0, 6);
        tcg_gen_xor_i64(cpu_T[0], cpu_T[0], cpu_tmp4);
        tcg_gen_or_i64(cpu_T[0], cpu_T[0], cpu_tmp0);
        tcg_gen_andi_i64(cpu_T[0], cpu_T[0], 1);
        break;
    }
}



static int is_fast_jcc_case(DisasContext *s, int b)
{
    int jcc_op;
    jcc_op = (b >> 1) & 7;
    switch(s->cc_op) {

    case CC_OP_SUBB:
    case CC_OP_SUBW:
    case CC_OP_SUBL:
    case CC_OP_SUBQ:
        if (jcc_op == JCC_O || jcc_op == JCC_P)
            goto slow_jcc;
        break;


    case CC_OP_ADDB:
    case CC_OP_ADDW:
    case CC_OP_ADDL:
    case CC_OP_ADDQ:

    case CC_OP_LOGICB:
    case CC_OP_LOGICW:
    case CC_OP_LOGICL:
    case CC_OP_LOGICQ:

    case CC_OP_INCB:
    case CC_OP_INCW:
    case CC_OP_INCL:
    case CC_OP_INCQ:

    case CC_OP_DECB:
    case CC_OP_DECW:
    case CC_OP_DECL:
    case CC_OP_DECQ:

    case CC_OP_SHLB:
    case CC_OP_SHLW:
    case CC_OP_SHLL:
    case CC_OP_SHLQ:
        if (jcc_op != JCC_Z && jcc_op != JCC_S)
            goto slow_jcc;
        break;
    default:
    slow_jcc:
        return 0;
    }
    return 1;
}



static __attribute__ (( always_inline )) __inline__ void gen_jcc1(DisasContext *s, int cc_op, int b, int l1)
{
    int inv, jcc_op, size, cond;
    TCGv_i64 t0;

    inv = b & 1;
    jcc_op = (b >> 1) & 7;

    switch(cc_op) {

    case CC_OP_SUBB:
    case CC_OP_SUBW:
    case CC_OP_SUBL:
    case CC_OP_SUBQ:

        size = cc_op - CC_OP_SUBB;
        switch(jcc_op) {
        case JCC_Z:
        fast_jcc_z:
            switch(size) {
            case 0:
                tcg_gen_andi_i64(cpu_tmp0, cpu_cc_dst, 0xff);
                t0 = cpu_tmp0;
                break;
            case 1:
                tcg_gen_andi_i64(cpu_tmp0, cpu_cc_dst, 0xffff);
                t0 = cpu_tmp0;
                break;

            case 2:
                tcg_gen_andi_i64(cpu_tmp0, cpu_cc_dst, 0xffffffff);
                t0 = cpu_tmp0;
                break;

            default:
                t0 = cpu_cc_dst;
                break;
            }
            tcg_gen_brcondi_i64(inv ? TCG_COND_NE : TCG_COND_EQ, t0, 0, l1);
            break;
        case JCC_S:
        fast_jcc_s:
            switch(size) {
            case 0:
                tcg_gen_andi_i64(cpu_tmp0, cpu_cc_dst, 0x80);
                tcg_gen_brcondi_i64(inv ? TCG_COND_EQ : TCG_COND_NE, cpu_tmp0,
                                   0, l1);
                break;
            case 1:
                tcg_gen_andi_i64(cpu_tmp0, cpu_cc_dst, 0x8000);
                tcg_gen_brcondi_i64(inv ? TCG_COND_EQ : TCG_COND_NE, cpu_tmp0,
                                   0, l1);
                break;

            case 2:
                tcg_gen_andi_i64(cpu_tmp0, cpu_cc_dst, 0x80000000);
                tcg_gen_brcondi_i64(inv ? TCG_COND_EQ : TCG_COND_NE, cpu_tmp0,
                                   0, l1);
                break;

            default:
                tcg_gen_brcondi_i64(inv ? TCG_COND_GE : TCG_COND_LT, cpu_cc_dst,
                                   0, l1);
                break;
            }
            break;

        case JCC_B:
            cond = inv ? TCG_COND_GEU : TCG_COND_LTU;
            goto fast_jcc_b;
        case JCC_BE:
            cond = inv ? TCG_COND_GTU : TCG_COND_LEU;
        fast_jcc_b:
            tcg_gen_add_i64(cpu_tmp4, cpu_cc_dst, cpu_cc_src);
            switch(size) {
            case 0:
                t0 = cpu_tmp0;
                tcg_gen_andi_i64(cpu_tmp4, cpu_tmp4, 0xff);
                tcg_gen_andi_i64(t0, cpu_cc_src, 0xff);
                break;
            case 1:
                t0 = cpu_tmp0;
                tcg_gen_andi_i64(cpu_tmp4, cpu_tmp4, 0xffff);
                tcg_gen_andi_i64(t0, cpu_cc_src, 0xffff);
                break;

            case 2:
                t0 = cpu_tmp0;
                tcg_gen_andi_i64(cpu_tmp4, cpu_tmp4, 0xffffffff);
                tcg_gen_andi_i64(t0, cpu_cc_src, 0xffffffff);
                break;

            default:
                t0 = cpu_cc_src;
                break;
            }
            tcg_gen_brcond_i64(cond, cpu_tmp4, t0, l1);
            break;

        case JCC_L:
            cond = inv ? TCG_COND_GE : TCG_COND_LT;
            goto fast_jcc_l;
        case JCC_LE:
            cond = inv ? TCG_COND_GT : TCG_COND_LE;
        fast_jcc_l:
            tcg_gen_add_i64(cpu_tmp4, cpu_cc_dst, cpu_cc_src);
            switch(size) {
            case 0:
                t0 = cpu_tmp0;
                tcg_gen_ext8s_i64(cpu_tmp4, cpu_tmp4);
                tcg_gen_ext8s_i64(t0, cpu_cc_src);
                break;
            case 1:
                t0 = cpu_tmp0;
                tcg_gen_ext16s_i64(cpu_tmp4, cpu_tmp4);
                tcg_gen_ext16s_i64(t0, cpu_cc_src);
                break;

            case 2:
                t0 = cpu_tmp0;
                tcg_gen_ext32s_i64(cpu_tmp4, cpu_tmp4);
                tcg_gen_ext32s_i64(t0, cpu_cc_src);
                break;

            default:
                t0 = cpu_cc_src;
                break;
            }
            tcg_gen_brcond_i64(cond, cpu_tmp4, t0, l1);
            break;

        default:
            goto slow_jcc;
        }
        break;


    case CC_OP_ADDB:
    case CC_OP_ADDW:
    case CC_OP_ADDL:
    case CC_OP_ADDQ:

    case CC_OP_ADCB:
    case CC_OP_ADCW:
    case CC_OP_ADCL:
    case CC_OP_ADCQ:

    case CC_OP_SBBB:
    case CC_OP_SBBW:
    case CC_OP_SBBL:
    case CC_OP_SBBQ:

    case CC_OP_LOGICB:
    case CC_OP_LOGICW:
    case CC_OP_LOGICL:
    case CC_OP_LOGICQ:

    case CC_OP_INCB:
    case CC_OP_INCW:
    case CC_OP_INCL:
    case CC_OP_INCQ:

    case CC_OP_DECB:
    case CC_OP_DECW:
    case CC_OP_DECL:
    case CC_OP_DECQ:

    case CC_OP_SHLB:
    case CC_OP_SHLW:
    case CC_OP_SHLL:
    case CC_OP_SHLQ:

    case CC_OP_SARB:
    case CC_OP_SARW:
    case CC_OP_SARL:
    case CC_OP_SARQ:
        switch(jcc_op) {
        case JCC_Z:
            size = (cc_op - CC_OP_ADDB) & 3;
            goto fast_jcc_z;
        case JCC_S:
            size = (cc_op - CC_OP_ADDB) & 3;
            goto fast_jcc_s;
        default:
            goto slow_jcc;
        }
        break;
    default:
    slow_jcc:
        gen_setcc_slow_T0(s, jcc_op);
        tcg_gen_brcondi_i64(inv ? TCG_COND_EQ : TCG_COND_NE,
                           cpu_T[0], 0, l1);
        break;
    }
}



static int gen_jz_ecx_string(DisasContext *s, target_ulong next_eip)
{
    int l1, l2;

    l1 = gen_new_label();
    l2 = gen_new_label();
    gen_op_jnz_ecx(s->aflag, l1);
    gen_set_label(l2);
    gen_jmp_tb(s, next_eip, 1);
    gen_set_label(l1);
    return l2;
}

static __attribute__ (( always_inline )) __inline__ void gen_stos(DisasContext *s, int ot)
{
    gen_op_mov_TN_reg(OT_LONG, 0, 0);
    gen_string_movl_A0_EDI(s);
    gen_op_st_T0_A0(ot + s->mem_index);
    gen_op_movl_T0_Dshift(ot);
    gen_op_add_reg_T0(s->aflag, 7);
}

static __attribute__ (( always_inline )) __inline__ void gen_lods(DisasContext *s, int ot)
{
    gen_string_movl_A0_ESI(s);
    gen_op_ld_T0_A0(ot + s->mem_index);
    gen_op_mov_reg_T0(ot, 0);
    gen_op_movl_T0_Dshift(ot);
    gen_op_add_reg_T0(s->aflag, 6);
}

static __attribute__ (( always_inline )) __inline__ void gen_scas(DisasContext *s, int ot)
{
    gen_op_mov_TN_reg(OT_LONG, 0, 0);
    gen_string_movl_A0_EDI(s);
    gen_op_ld_T1_A0(ot + s->mem_index);
    gen_op_cmpl_T0_T1_cc();
    gen_op_movl_T0_Dshift(ot);
    gen_op_add_reg_T0(s->aflag, 7);
}

static __attribute__ (( always_inline )) __inline__ void gen_cmps(DisasContext *s, int ot)
{
    gen_string_movl_A0_ESI(s);
    gen_op_ld_T0_A0(ot + s->mem_index);
    gen_string_movl_A0_EDI(s);
    gen_op_ld_T1_A0(ot + s->mem_index);
    gen_op_cmpl_T0_T1_cc();
    gen_op_movl_T0_Dshift(ot);
    gen_op_add_reg_T0(s->aflag, 6);
    gen_op_add_reg_T0(s->aflag, 7);
}

static __attribute__ (( always_inline )) __inline__ void gen_ins(DisasContext *s, int ot)
{
    if (use_icount)
        gen_io_start();
    gen_string_movl_A0_EDI(s);


    gen_op_movl_T0_0();
    gen_op_st_T0_A0(ot + s->mem_index);
    gen_op_mov_TN_reg(OT_WORD, 1, 2);
    tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[1]);
    tcg_gen_andi_i32(cpu_tmp2_i32, cpu_tmp2_i32, 0xffff);
    gen_helper_in_func(ot, cpu_T[0], cpu_tmp2_i32);
    gen_op_st_T0_A0(ot + s->mem_index);
    gen_op_movl_T0_Dshift(ot);
    gen_op_add_reg_T0(s->aflag, 7);
    if (use_icount)
        gen_io_end();
}

static __attribute__ (( always_inline )) __inline__ void gen_outs(DisasContext *s, int ot)
{
    if (use_icount)
        gen_io_start();
    gen_string_movl_A0_ESI(s);
    gen_op_ld_T0_A0(ot + s->mem_index);

    gen_op_mov_TN_reg(OT_WORD, 1, 2);
    tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[1]);
    tcg_gen_andi_i32(cpu_tmp2_i32, cpu_tmp2_i32, 0xffff);
    tcg_gen_trunc_i64_i32(cpu_tmp3_i32, cpu_T[0]);
    gen_helper_out_func(ot, cpu_tmp2_i32, cpu_tmp3_i32);

    gen_op_movl_T0_Dshift(ot);
    gen_op_add_reg_T0(s->aflag, 6);
    if (use_icount)
        gen_io_end();
}
# 1249 "../../target-i386/translate.c"
static __attribute__ (( always_inline )) __inline__ void gen_repz_movs(DisasContext *s, int ot, target_ulong cur_eip, target_ulong next_eip) { int l2; gen_update_cc_op(s); l2 = gen_jz_ecx_string(s, next_eip); gen_movs(s, ot); gen_op_add_reg_im(s->aflag, 1, -1); if (!s->jmp_opt) gen_op_jz_ecx(s->aflag, l2); gen_jmp(s, cur_eip); }
static __attribute__ (( always_inline )) __inline__ void gen_repz_stos(DisasContext *s, int ot, target_ulong cur_eip, target_ulong next_eip) { int l2; gen_update_cc_op(s); l2 = gen_jz_ecx_string(s, next_eip); gen_stos(s, ot); gen_op_add_reg_im(s->aflag, 1, -1); if (!s->jmp_opt) gen_op_jz_ecx(s->aflag, l2); gen_jmp(s, cur_eip); }
static __attribute__ (( always_inline )) __inline__ void gen_repz_lods(DisasContext *s, int ot, target_ulong cur_eip, target_ulong next_eip) { int l2; gen_update_cc_op(s); l2 = gen_jz_ecx_string(s, next_eip); gen_lods(s, ot); gen_op_add_reg_im(s->aflag, 1, -1); if (!s->jmp_opt) gen_op_jz_ecx(s->aflag, l2); gen_jmp(s, cur_eip); }
static __attribute__ (( always_inline )) __inline__ void gen_repz_ins(DisasContext *s, int ot, target_ulong cur_eip, target_ulong next_eip) { int l2; gen_update_cc_op(s); l2 = gen_jz_ecx_string(s, next_eip); gen_ins(s, ot); gen_op_add_reg_im(s->aflag, 1, -1); if (!s->jmp_opt) gen_op_jz_ecx(s->aflag, l2); gen_jmp(s, cur_eip); }
static __attribute__ (( always_inline )) __inline__ void gen_repz_outs(DisasContext *s, int ot, target_ulong cur_eip, target_ulong next_eip) { int l2; gen_update_cc_op(s); l2 = gen_jz_ecx_string(s, next_eip); gen_outs(s, ot); gen_op_add_reg_im(s->aflag, 1, -1); if (!s->jmp_opt) gen_op_jz_ecx(s->aflag, l2); gen_jmp(s, cur_eip); }
static __attribute__ (( always_inline )) __inline__ void gen_repz_scas(DisasContext *s, int ot, target_ulong cur_eip, target_ulong next_eip, int nz) { int l2; gen_update_cc_op(s); l2 = gen_jz_ecx_string(s, next_eip); gen_scas(s, ot); gen_op_add_reg_im(s->aflag, 1, -1); gen_op_set_cc_op(CC_OP_SUBB + ot); gen_jcc1(s, CC_OP_SUBB + ot, (JCC_Z << 1) | (nz ^ 1), l2); if (!s->jmp_opt) gen_op_jz_ecx(s->aflag, l2); gen_jmp(s, cur_eip); }
static __attribute__ (( always_inline )) __inline__ void gen_repz_cmps(DisasContext *s, int ot, target_ulong cur_eip, target_ulong next_eip, int nz) { int l2; gen_update_cc_op(s); l2 = gen_jz_ecx_string(s, next_eip); gen_cmps(s, ot); gen_op_add_reg_im(s->aflag, 1, -1); gen_op_set_cc_op(CC_OP_SUBB + ot); gen_jcc1(s, CC_OP_SUBB + ot, (JCC_Z << 1) | (nz ^ 1), l2); if (!s->jmp_opt) gen_op_jz_ecx(s->aflag, l2); gen_jmp(s, cur_eip); }

static void gen_helper_fp_arith_ST0_FT0(int op)
{
    switch (op) {
    case 0: gen_helper_fadd_ST0_FT0(); break;
    case 1: gen_helper_fmul_ST0_FT0(); break;
    case 2: gen_helper_fcom_ST0_FT0(); break;
    case 3: gen_helper_fcom_ST0_FT0(); break;
    case 4: gen_helper_fsub_ST0_FT0(); break;
    case 5: gen_helper_fsubr_ST0_FT0(); break;
    case 6: gen_helper_fdiv_ST0_FT0(); break;
    case 7: gen_helper_fdivr_ST0_FT0(); break;
    }
}


static void gen_helper_fp_arith_STN_ST0(int op, int opreg)
{
    TCGv_i32 tmp = tcg_const_i32(opreg);
    switch (op) {
    case 0: gen_helper_fadd_STN_ST0(tmp); break;
    case 1: gen_helper_fmul_STN_ST0(tmp); break;
    case 4: gen_helper_fsubr_STN_ST0(tmp); break;
    case 5: gen_helper_fsub_STN_ST0(tmp); break;
    case 6: gen_helper_fdivr_STN_ST0(tmp); break;
    case 7: gen_helper_fdiv_STN_ST0(tmp); break;
    }
}


static void gen_op(DisasContext *s1, int op, int ot, int d)
{
    if (d != OR_TMP0) {
        gen_op_mov_TN_reg(ot, 0, d);
    } else {
        gen_op_ld_T0_A0(ot + s1->mem_index);
    }
    switch(op) {
    case OP_ADCL:
        if (s1->cc_op != CC_OP_DYNAMIC)
            gen_op_set_cc_op(s1->cc_op);
        gen_compute_eflags_c(cpu_tmp4);
        tcg_gen_add_i64(cpu_T[0], cpu_T[0], cpu_T[1]);
        tcg_gen_add_i64(cpu_T[0], cpu_T[0], cpu_tmp4);
        if (d != OR_TMP0)
            gen_op_mov_reg_T0(ot, d);
        else
            gen_op_st_T0_A0(ot + s1->mem_index);
        tcg_gen_mov_i64(cpu_cc_src, cpu_T[1]);
        tcg_gen_mov_i64(cpu_cc_dst, cpu_T[0]);
        tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_tmp4);
        tcg_gen_shli_i32(cpu_tmp2_i32, cpu_tmp2_i32, 2);
        tcg_gen_addi_i32(cpu_cc_op, cpu_tmp2_i32, CC_OP_ADDB + ot);
        s1->cc_op = CC_OP_DYNAMIC;
        break;
    case OP_SBBL:
        if (s1->cc_op != CC_OP_DYNAMIC)
            gen_op_set_cc_op(s1->cc_op);
        gen_compute_eflags_c(cpu_tmp4);
        tcg_gen_sub_i64(cpu_T[0], cpu_T[0], cpu_T[1]);
        tcg_gen_sub_i64(cpu_T[0], cpu_T[0], cpu_tmp4);
        if (d != OR_TMP0)
            gen_op_mov_reg_T0(ot, d);
        else
            gen_op_st_T0_A0(ot + s1->mem_index);
        tcg_gen_mov_i64(cpu_cc_src, cpu_T[1]);
        tcg_gen_mov_i64(cpu_cc_dst, cpu_T[0]);
        tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_tmp4);
        tcg_gen_shli_i32(cpu_tmp2_i32, cpu_tmp2_i32, 2);
        tcg_gen_addi_i32(cpu_cc_op, cpu_tmp2_i32, CC_OP_SUBB + ot);
        s1->cc_op = CC_OP_DYNAMIC;
        break;
    case OP_ADDL:
        gen_op_addl_T0_T1();
        if (d != OR_TMP0)
            gen_op_mov_reg_T0(ot, d);
        else
            gen_op_st_T0_A0(ot + s1->mem_index);
        gen_op_update2_cc();
        s1->cc_op = CC_OP_ADDB + ot;
        break;
    case OP_SUBL:
        tcg_gen_sub_i64(cpu_T[0], cpu_T[0], cpu_T[1]);
        if (d != OR_TMP0)
            gen_op_mov_reg_T0(ot, d);
        else
            gen_op_st_T0_A0(ot + s1->mem_index);
        gen_op_update2_cc();
        s1->cc_op = CC_OP_SUBB + ot;
        break;
    default:
    case OP_ANDL:
        tcg_gen_and_i64(cpu_T[0], cpu_T[0], cpu_T[1]);
        if (d != OR_TMP0)
            gen_op_mov_reg_T0(ot, d);
        else
            gen_op_st_T0_A0(ot + s1->mem_index);
        gen_op_update1_cc();
        s1->cc_op = CC_OP_LOGICB + ot;
        break;
    case OP_ORL:
        tcg_gen_or_i64(cpu_T[0], cpu_T[0], cpu_T[1]);
        if (d != OR_TMP0)
            gen_op_mov_reg_T0(ot, d);
        else
            gen_op_st_T0_A0(ot + s1->mem_index);
        gen_op_update1_cc();
        s1->cc_op = CC_OP_LOGICB + ot;
        break;
    case OP_XORL:
        tcg_gen_xor_i64(cpu_T[0], cpu_T[0], cpu_T[1]);
        if (d != OR_TMP0)
            gen_op_mov_reg_T0(ot, d);
        else
            gen_op_st_T0_A0(ot + s1->mem_index);
        gen_op_update1_cc();
        s1->cc_op = CC_OP_LOGICB + ot;
        break;
    case OP_CMPL:
        gen_op_cmpl_T0_T1_cc();
        s1->cc_op = CC_OP_SUBB + ot;
        break;
    }
}


static void gen_inc(DisasContext *s1, int ot, int d, int c)
{
    if (d != OR_TMP0)
        gen_op_mov_TN_reg(ot, 0, d);
    else
        gen_op_ld_T0_A0(ot + s1->mem_index);
    if (s1->cc_op != CC_OP_DYNAMIC)
        gen_op_set_cc_op(s1->cc_op);
    if (c > 0) {
        tcg_gen_addi_i64(cpu_T[0], cpu_T[0], 1);
        s1->cc_op = CC_OP_INCB + ot;
    } else {
        tcg_gen_addi_i64(cpu_T[0], cpu_T[0], -1);
        s1->cc_op = CC_OP_DECB + ot;
    }
    if (d != OR_TMP0)
        gen_op_mov_reg_T0(ot, d);
    else
        gen_op_st_T0_A0(ot + s1->mem_index);
    gen_compute_eflags_c(cpu_cc_src);
    tcg_gen_mov_i64(cpu_cc_dst, cpu_T[0]);
}

static void gen_shift_rm_T1(DisasContext *s, int ot, int op1,
                            int is_right, int is_arith)
{
    target_ulong mask;
    int shift_label;
    TCGv_i64 t0, t1;

    if (ot == OT_QUAD)
        mask = 0x3f;
    else
        mask = 0x1f;


    if (op1 == OR_TMP0)
        gen_op_ld_T0_A0(ot + s->mem_index);
    else
        gen_op_mov_TN_reg(ot, 0, op1);

    tcg_gen_andi_i64(cpu_T[1], cpu_T[1], mask);

    tcg_gen_addi_i64(cpu_tmp5, cpu_T[1], -1);

    if (is_right) {
        if (is_arith) {
            gen_exts(ot, cpu_T[0]);
            tcg_gen_sar_i64(cpu_T3, cpu_T[0], cpu_tmp5);
            tcg_gen_sar_i64(cpu_T[0], cpu_T[0], cpu_T[1]);
        } else {
            gen_extu(ot, cpu_T[0]);
            tcg_gen_shr_i64(cpu_T3, cpu_T[0], cpu_tmp5);
            tcg_gen_shr_i64(cpu_T[0], cpu_T[0], cpu_T[1]);
        }
    } else {
        tcg_gen_shl_i64(cpu_T3, cpu_T[0], cpu_tmp5);
        tcg_gen_shl_i64(cpu_T[0], cpu_T[0], cpu_T[1]);
    }


    if (op1 == OR_TMP0)
        gen_op_st_T0_A0(ot + s->mem_index);
    else
        gen_op_mov_reg_T0(ot, op1);


    if (s->cc_op != CC_OP_DYNAMIC)
        gen_op_set_cc_op(s->cc_op);


    t0 = tcg_temp_local_new_i64();
    t1 = tcg_temp_local_new_i64();

    tcg_gen_mov_i64(t0, cpu_T[0]);
    tcg_gen_mov_i64(t1, cpu_T3);

    shift_label = gen_new_label();
    tcg_gen_brcondi_i64(TCG_COND_EQ, cpu_T[1], 0, shift_label);

    tcg_gen_mov_i64(cpu_cc_src, t1);
    tcg_gen_mov_i64(cpu_cc_dst, t0);
    if (is_right)
        tcg_gen_movi_i32(cpu_cc_op, CC_OP_SARB + ot);
    else
        tcg_gen_movi_i32(cpu_cc_op, CC_OP_SHLB + ot);

    gen_set_label(shift_label);
    s->cc_op = CC_OP_DYNAMIC;

    tcg_temp_free_i64(t0);
    tcg_temp_free_i64(t1);
}

static void gen_shift_rm_im(DisasContext *s, int ot, int op1, int op2,
                            int is_right, int is_arith)
{
    int mask;

    if (ot == OT_QUAD)
        mask = 0x3f;
    else
        mask = 0x1f;


    if (op1 == OR_TMP0)
        gen_op_ld_T0_A0(ot + s->mem_index);
    else
        gen_op_mov_TN_reg(ot, 0, op1);

    op2 &= mask;
    if (op2 != 0) {
        if (is_right) {
            if (is_arith) {
                gen_exts(ot, cpu_T[0]);
                tcg_gen_sari_i64(cpu_tmp4, cpu_T[0], op2 - 1);
                tcg_gen_sari_i64(cpu_T[0], cpu_T[0], op2);
            } else {
                gen_extu(ot, cpu_T[0]);
                tcg_gen_shri_i64(cpu_tmp4, cpu_T[0], op2 - 1);
                tcg_gen_shri_i64(cpu_T[0], cpu_T[0], op2);
            }
        } else {
            tcg_gen_shli_i64(cpu_tmp4, cpu_T[0], op2 - 1);
            tcg_gen_shli_i64(cpu_T[0], cpu_T[0], op2);
        }
    }


    if (op1 == OR_TMP0)
        gen_op_st_T0_A0(ot + s->mem_index);
    else
        gen_op_mov_reg_T0(ot, op1);


    if (op2 != 0) {
        tcg_gen_mov_i64(cpu_cc_src, cpu_tmp4);
        tcg_gen_mov_i64(cpu_cc_dst, cpu_T[0]);
        if (is_right)
            s->cc_op = CC_OP_SARB + ot;
        else
            s->cc_op = CC_OP_SHLB + ot;
    }
}

static __attribute__ (( always_inline )) __inline__ void tcg_gen_lshift(TCGv_i64 ret, TCGv_i64 arg1, target_long arg2)
{
    if (arg2 >= 0)
        tcg_gen_shli_i64(ret, arg1, arg2);
    else
        tcg_gen_shri_i64(ret, arg1, -arg2);
}

static void gen_rot_rm_T1(DisasContext *s, int ot, int op1,
                          int is_right)
{
    target_ulong mask;
    int label1, label2, data_bits;
    TCGv_i64 t0, t1, t2, a0;


    t0 = tcg_temp_local_new_i64();
    t1 = tcg_temp_local_new_i64();
    t2 = tcg_temp_local_new_i64();
    a0 = tcg_temp_local_new_i64();

    if (ot == OT_QUAD)
        mask = 0x3f;
    else
        mask = 0x1f;


    if (op1 == OR_TMP0) {
        tcg_gen_mov_i64(a0, cpu_A0);
        gen_op_ld_v(ot + s->mem_index, t0, a0);
    } else {
        gen_op_mov_v_reg(ot, t0, op1);
    }

    tcg_gen_mov_i64(t1, cpu_T[1]);

    tcg_gen_andi_i64(t1, t1, mask);



    label1 = gen_new_label();
    tcg_gen_brcondi_i64(TCG_COND_EQ, t1, 0, label1);

    if (ot <= OT_WORD)
        tcg_gen_andi_i64(cpu_tmp0, t1, (1 << (3 + ot)) - 1);
    else
        tcg_gen_mov_i64(cpu_tmp0, t1);

    gen_extu(ot, t0);
    tcg_gen_mov_i64(t2, t0);

    data_bits = 8 << ot;


    if (is_right) {
        tcg_gen_shr_i64(cpu_tmp4, t0, cpu_tmp0);
        tcg_gen_subfi_i64(cpu_tmp0, data_bits, cpu_tmp0);
        tcg_gen_shl_i64(t0, t0, cpu_tmp0);
    } else {
        tcg_gen_shl_i64(cpu_tmp4, t0, cpu_tmp0);
        tcg_gen_subfi_i64(cpu_tmp0, data_bits, cpu_tmp0);
        tcg_gen_shr_i64(t0, t0, cpu_tmp0);
    }
    tcg_gen_or_i64(t0, t0, cpu_tmp4);

    gen_set_label(label1);

    if (op1 == OR_TMP0) {
        gen_op_st_v(ot + s->mem_index, t0, a0);
    } else {
        gen_op_mov_reg_v(ot, op1, t0);
    }


    if (s->cc_op != CC_OP_DYNAMIC)
        gen_op_set_cc_op(s->cc_op);

    label2 = gen_new_label();
    tcg_gen_brcondi_i64(TCG_COND_EQ, t1, 0, label2);

    gen_compute_eflags(cpu_cc_src);
    tcg_gen_andi_i64(cpu_cc_src, cpu_cc_src, ~(0x0800 | 0x0001));
    tcg_gen_xor_i64(cpu_tmp0, t2, t0);
    tcg_gen_lshift(cpu_tmp0, cpu_tmp0, 11 - (data_bits - 1));
    tcg_gen_andi_i64(cpu_tmp0, cpu_tmp0, 0x0800);
    tcg_gen_or_i64(cpu_cc_src, cpu_cc_src, cpu_tmp0);
    if (is_right) {
        tcg_gen_shri_i64(t0, t0, data_bits - 1);
    }
    tcg_gen_andi_i64(t0, t0, 0x0001);
    tcg_gen_or_i64(cpu_cc_src, cpu_cc_src, t0);

    tcg_gen_discard_i64(cpu_cc_dst);
    tcg_gen_movi_i32(cpu_cc_op, CC_OP_EFLAGS);

    gen_set_label(label2);
    s->cc_op = CC_OP_DYNAMIC;

    tcg_temp_free_i64(t0);
    tcg_temp_free_i64(t1);
    tcg_temp_free_i64(t2);
    tcg_temp_free_i64(a0);
}

static void gen_rot_rm_im(DisasContext *s, int ot, int op1, int op2,
                          int is_right)
{
    int mask;
    int data_bits;
    TCGv_i64 t0, t1, a0;


    t0 = tcg_temp_local_new_i64();
    t1 = tcg_temp_local_new_i64();
    a0 = tcg_temp_local_new_i64();

    if (ot == OT_QUAD)
        mask = 0x3f;
    else
        mask = 0x1f;


    if (op1 == OR_TMP0) {
        tcg_gen_mov_i64(a0, cpu_A0);
        gen_op_ld_v(ot + s->mem_index, t0, a0);
    } else {
        gen_op_mov_v_reg(ot, t0, op1);
    }

    gen_extu(ot, t0);
    tcg_gen_mov_i64(t1, t0);

    op2 &= mask;
    data_bits = 8 << ot;
    if (op2 != 0) {
        int shift = op2 & ((1 << (3 + ot)) - 1);
        if (is_right) {
            tcg_gen_shri_i64(cpu_tmp4, t0, shift);
            tcg_gen_shli_i64(t0, t0, data_bits - shift);
        }
        else {
            tcg_gen_shli_i64(cpu_tmp4, t0, shift);
            tcg_gen_shri_i64(t0, t0, data_bits - shift);
        }
        tcg_gen_or_i64(t0, t0, cpu_tmp4);
    }


    if (op1 == OR_TMP0) {
        gen_op_st_v(ot + s->mem_index, t0, a0);
    } else {
        gen_op_mov_reg_v(ot, op1, t0);
    }

    if (op2 != 0) {

        if (s->cc_op != CC_OP_DYNAMIC)
            gen_op_set_cc_op(s->cc_op);

        gen_compute_eflags(cpu_cc_src);
        tcg_gen_andi_i64(cpu_cc_src, cpu_cc_src, ~(0x0800 | 0x0001));
        tcg_gen_xor_i64(cpu_tmp0, t1, t0);
        tcg_gen_lshift(cpu_tmp0, cpu_tmp0, 11 - (data_bits - 1));
        tcg_gen_andi_i64(cpu_tmp0, cpu_tmp0, 0x0800);
        tcg_gen_or_i64(cpu_cc_src, cpu_cc_src, cpu_tmp0);
        if (is_right) {
            tcg_gen_shri_i64(t0, t0, data_bits - 1);
        }
        tcg_gen_andi_i64(t0, t0, 0x0001);
        tcg_gen_or_i64(cpu_cc_src, cpu_cc_src, t0);

        tcg_gen_discard_i64(cpu_cc_dst);
        tcg_gen_movi_i32(cpu_cc_op, CC_OP_EFLAGS);
        s->cc_op = CC_OP_EFLAGS;
    }

    tcg_temp_free_i64(t0);
    tcg_temp_free_i64(t1);
    tcg_temp_free_i64(a0);
}


static void gen_rotc_rm_T1(DisasContext *s, int ot, int op1,
                           int is_right)
{
    int label1;

    if (s->cc_op != CC_OP_DYNAMIC)
        gen_op_set_cc_op(s->cc_op);


    if (op1 == OR_TMP0)
        gen_op_ld_T0_A0(ot + s->mem_index);
    else
        gen_op_mov_TN_reg(ot, 0, op1);

    if (is_right) {
        switch (ot) {
        case 0: gen_helper_rcrb(cpu_T[0], cpu_T[0], cpu_T[1]); break;
        case 1: gen_helper_rcrw(cpu_T[0], cpu_T[0], cpu_T[1]); break;
        case 2: gen_helper_rcrl(cpu_T[0], cpu_T[0], cpu_T[1]); break;

        case 3: gen_helper_rcrq(cpu_T[0], cpu_T[0], cpu_T[1]); break;

        }
    } else {
        switch (ot) {
        case 0: gen_helper_rclb(cpu_T[0], cpu_T[0], cpu_T[1]); break;
        case 1: gen_helper_rclw(cpu_T[0], cpu_T[0], cpu_T[1]); break;
        case 2: gen_helper_rcll(cpu_T[0], cpu_T[0], cpu_T[1]); break;

        case 3: gen_helper_rclq(cpu_T[0], cpu_T[0], cpu_T[1]); break;

        }
    }

    if (op1 == OR_TMP0)
        gen_op_st_T0_A0(ot + s->mem_index);
    else
        gen_op_mov_reg_T0(ot, op1);


    label1 = gen_new_label();
    tcg_gen_brcondi_i64(TCG_COND_EQ, cpu_cc_tmp, -1, label1);

    tcg_gen_mov_i64(cpu_cc_src, cpu_cc_tmp);
    tcg_gen_discard_i64(cpu_cc_dst);
    tcg_gen_movi_i32(cpu_cc_op, CC_OP_EFLAGS);

    gen_set_label(label1);
    s->cc_op = CC_OP_DYNAMIC;
}


static void gen_shiftd_rm_T1_T3(DisasContext *s, int ot, int op1,
                                int is_right)
{
    int label1, label2, data_bits;
    target_ulong mask;
    TCGv_i64 t0, t1, t2, a0;

    t0 = tcg_temp_local_new_i64();
    t1 = tcg_temp_local_new_i64();
    t2 = tcg_temp_local_new_i64();
    a0 = tcg_temp_local_new_i64();

    if (ot == OT_QUAD)
        mask = 0x3f;
    else
        mask = 0x1f;


    if (op1 == OR_TMP0) {
        tcg_gen_mov_i64(a0, cpu_A0);
        gen_op_ld_v(ot + s->mem_index, t0, a0);
    } else {
        gen_op_mov_v_reg(ot, t0, op1);
    }

    tcg_gen_andi_i64(cpu_T3, cpu_T3, mask);

    tcg_gen_mov_i64(t1, cpu_T[1]);
    tcg_gen_mov_i64(t2, cpu_T3);



    label1 = gen_new_label();
    tcg_gen_brcondi_i64(TCG_COND_EQ, t2, 0, label1);

    tcg_gen_addi_i64(cpu_tmp5, t2, -1);
    if (ot == OT_WORD) {

        if (is_right) {
            tcg_gen_andi_i64(t0, t0, 0xffff);
            tcg_gen_shli_i64(cpu_tmp0, t1, 16);
            tcg_gen_or_i64(t0, t0, cpu_tmp0);
            tcg_gen_ext32u_i64(t0, t0);

            tcg_gen_shr_i64(cpu_tmp4, t0, cpu_tmp5);


            tcg_gen_subfi_i64(cpu_tmp5, 32, t2);
            tcg_gen_shl_i64(cpu_tmp0, t0, cpu_tmp5);

            tcg_gen_shr_i64(t0, t0, t2);

            tcg_gen_or_i64(t0, t0, cpu_tmp0);
        } else {

            tcg_gen_andi_i64(t0, t0, 0xffff);
            tcg_gen_shli_i64(t1, t1, 16);
            tcg_gen_or_i64(t1, t1, t0);
            tcg_gen_ext32u_i64(t1, t1);

            tcg_gen_shl_i64(cpu_tmp4, t0, cpu_tmp5);
            tcg_gen_subfi_i64(cpu_tmp0, 32, cpu_tmp5);
            tcg_gen_shr_i64(cpu_tmp5, t1, cpu_tmp0);
            tcg_gen_or_i64(cpu_tmp4, cpu_tmp4, cpu_tmp5);

            tcg_gen_shl_i64(t0, t0, t2);
            tcg_gen_subfi_i64(cpu_tmp5, 32, t2);
            tcg_gen_shr_i64(t1, t1, cpu_tmp5);
            tcg_gen_or_i64(t0, t0, t1);
        }
    } else {
        data_bits = 8 << ot;
        if (is_right) {
            if (ot == OT_LONG)
                tcg_gen_ext32u_i64(t0, t0);

            tcg_gen_shr_i64(cpu_tmp4, t0, cpu_tmp5);

            tcg_gen_shr_i64(t0, t0, t2);
            tcg_gen_subfi_i64(cpu_tmp5, data_bits, t2);
            tcg_gen_shl_i64(t1, t1, cpu_tmp5);
            tcg_gen_or_i64(t0, t0, t1);

        } else {
            if (ot == OT_LONG)
                tcg_gen_ext32u_i64(t1, t1);

            tcg_gen_shl_i64(cpu_tmp4, t0, cpu_tmp5);

            tcg_gen_shl_i64(t0, t0, t2);
            tcg_gen_subfi_i64(cpu_tmp5, data_bits, t2);
            tcg_gen_shr_i64(t1, t1, cpu_tmp5);
            tcg_gen_or_i64(t0, t0, t1);
        }
    }
    tcg_gen_mov_i64(t1, cpu_tmp4);

    gen_set_label(label1);

    if (op1 == OR_TMP0) {
        gen_op_st_v(ot + s->mem_index, t0, a0);
    } else {
        gen_op_mov_reg_v(ot, op1, t0);
    }


    if (s->cc_op != CC_OP_DYNAMIC)
        gen_op_set_cc_op(s->cc_op);

    label2 = gen_new_label();
    tcg_gen_brcondi_i64(TCG_COND_EQ, t2, 0, label2);

    tcg_gen_mov_i64(cpu_cc_src, t1);
    tcg_gen_mov_i64(cpu_cc_dst, t0);
    if (is_right) {
        tcg_gen_movi_i32(cpu_cc_op, CC_OP_SARB + ot);
    } else {
        tcg_gen_movi_i32(cpu_cc_op, CC_OP_SHLB + ot);
    }
    gen_set_label(label2);
    s->cc_op = CC_OP_DYNAMIC;

    tcg_temp_free_i64(t0);
    tcg_temp_free_i64(t1);
    tcg_temp_free_i64(t2);
    tcg_temp_free_i64(a0);
}

static void gen_shift(DisasContext *s1, int op, int ot, int d, int s)
{
    if (s != OR_TMP1)
        gen_op_mov_TN_reg(ot, 1, s);
    switch(op) {
    case OP_ROL:
        gen_rot_rm_T1(s1, ot, d, 0);
        break;
    case OP_ROR:
        gen_rot_rm_T1(s1, ot, d, 1);
        break;
    case OP_SHL:
    case OP_SHL1:
        gen_shift_rm_T1(s1, ot, d, 0, 0);
        break;
    case OP_SHR:
        gen_shift_rm_T1(s1, ot, d, 1, 0);
        break;
    case OP_SAR:
        gen_shift_rm_T1(s1, ot, d, 1, 1);
        break;
    case OP_RCL:
        gen_rotc_rm_T1(s1, ot, d, 0);
        break;
    case OP_RCR:
        gen_rotc_rm_T1(s1, ot, d, 1);
        break;
    }
}

static void gen_shifti(DisasContext *s1, int op, int ot, int d, int c)
{
    switch(op) {
    case OP_ROL:
        gen_rot_rm_im(s1, ot, d, c, 0);
        break;
    case OP_ROR:
        gen_rot_rm_im(s1, ot, d, c, 1);
        break;
    case OP_SHL:
    case OP_SHL1:
        gen_shift_rm_im(s1, ot, d, c, 0, 0);
        break;
    case OP_SHR:
        gen_shift_rm_im(s1, ot, d, c, 1, 0);
        break;
    case OP_SAR:
        gen_shift_rm_im(s1, ot, d, c, 1, 1);
        break;
    default:

        gen_op_movl_T1_im(c);
        gen_shift(s1, op, ot, d, OR_TMP1);
        break;
    }
}

static void gen_lea_modrm(DisasContext *s, int modrm, int *reg_ptr, int *offset_ptr)
{
    target_long disp;
    int havesib;
    int base;
    int index;
    int scale;
    int opreg;
    int mod, rm, code, override, must_add_seg;

    override = s->override;
    must_add_seg = s->addseg;
    if (override >= 0)
        must_add_seg = 1;
    mod = (modrm >> 6) & 3;
    rm = modrm & 7;

    if (s->aflag) {

        havesib = 0;
        base = rm;
        index = 0;
        scale = 0;

        if (base == 4) {
            havesib = 1;
            code = ldub_code(s->pc++);
            scale = (code >> 6) & 3;
            index = ((code >> 3) & 7) | ((s)->rex_x);
            base = (code & 7);
        }
        base |= ((s)->rex_b);

        switch (mod) {
        case 0:
            if ((base & 7) == 5) {
                base = -1;
                disp = (int32_t)ldl_code(s->pc);
                s->pc += 4;
                if (((s)->code64) && !havesib) {
                    disp += s->pc + s->rip_offset;
                }
            } else {
                disp = 0;
            }
            break;
        case 1:
            disp = (int8_t)ldub_code(s->pc++);
            break;
        default:
        case 2:
            disp = (int32_t)ldl_code(s->pc);
            s->pc += 4;
            break;
        }

        if (base >= 0) {

            if (base == 4 && s->popl_esp_hack)
                disp += s->popl_esp_hack;

            if (s->aflag == 2) {
                gen_op_movq_A0_reg(base);
                if (disp != 0) {
                    gen_op_addq_A0_im(disp);
                }
            } else

            {
                gen_op_movl_A0_reg(base);
                if (disp != 0)
                    gen_op_addl_A0_im(disp);
            }
        } else {

            if (s->aflag == 2) {
                gen_op_movq_A0_im(disp);
            } else

            {
                gen_op_movl_A0_im(disp);
            }
        }

        if (havesib && (index != 4)) {

            if (s->aflag == 2) {
                gen_op_addq_A0_reg_sN(scale, index);
            } else

            {
                gen_op_addl_A0_reg_sN(scale, index);
            }
        }
        if (must_add_seg) {
            if (override < 0) {
                if (base == 5 || base == 4)
                    override = 2;
                else
                    override = 3;
            }

            if (s->aflag == 2) {
                gen_op_addq_A0_seg(override);
            } else

            {
                gen_op_addl_A0_seg(override);
            }
        }
    } else {
        switch (mod) {
        case 0:
            if (rm == 6) {
                disp = lduw_code(s->pc);
                s->pc += 2;
                gen_op_movl_A0_im(disp);
                rm = 0;
                goto no_rm;
            } else {
                disp = 0;
            }
            break;
        case 1:
            disp = (int8_t)ldub_code(s->pc++);
            break;
        default:
        case 2:
            disp = lduw_code(s->pc);
            s->pc += 2;
            break;
        }
        switch(rm) {
        case 0:
            gen_op_movl_A0_reg(3);
            gen_op_addl_A0_reg_sN(0, 6);
            break;
        case 1:
            gen_op_movl_A0_reg(3);
            gen_op_addl_A0_reg_sN(0, 7);
            break;
        case 2:
            gen_op_movl_A0_reg(5);
            gen_op_addl_A0_reg_sN(0, 6);
            break;
        case 3:
            gen_op_movl_A0_reg(5);
            gen_op_addl_A0_reg_sN(0, 7);
            break;
        case 4:
            gen_op_movl_A0_reg(6);
            break;
        case 5:
            gen_op_movl_A0_reg(7);
            break;
        case 6:
            gen_op_movl_A0_reg(5);
            break;
        default:
        case 7:
            gen_op_movl_A0_reg(3);
            break;
        }
        if (disp != 0)
            gen_op_addl_A0_im(disp);
        gen_op_andl_A0_ffff();
    no_rm:
        if (must_add_seg) {
            if (override < 0) {
                if (rm == 2 || rm == 3 || rm == 6)
                    override = 2;
                else
                    override = 3;
            }
            gen_op_addl_A0_seg(override);
        }
    }

    opreg = OR_A0;
    disp = 0;
    *reg_ptr = opreg;
    *offset_ptr = disp;
}

static void gen_nop_modrm(DisasContext *s, int modrm)
{
    int mod, rm, base, code;

    mod = (modrm >> 6) & 3;
    if (mod == 3)
        return;
    rm = modrm & 7;

    if (s->aflag) {

        base = rm;

        if (base == 4) {
            code = ldub_code(s->pc++);
            base = (code & 7);
        }

        switch (mod) {
        case 0:
            if (base == 5) {
                s->pc += 4;
            }
            break;
        case 1:
            s->pc++;
            break;
        default:
        case 2:
            s->pc += 4;
            break;
        }
    } else {
        switch (mod) {
        case 0:
            if (rm == 6) {
                s->pc += 2;
            }
            break;
        case 1:
            s->pc++;
            break;
        default:
        case 2:
            s->pc += 2;
            break;
        }
    }
}


static void gen_add_A0_ds_seg(DisasContext *s)
{
    int override, must_add_seg;
    must_add_seg = s->addseg;
    override = 3;
    if (s->override >= 0) {
        override = s->override;
        must_add_seg = 1;
    }
    if (must_add_seg) {

        if (((s)->code64)) {
            gen_op_addq_A0_seg(override);
        } else

        {
            gen_op_addl_A0_seg(override);
        }
    }
}



static void gen_ldst_modrm(DisasContext *s, int modrm, int ot, int reg, int is_store)
{
    int mod, rm, opreg, disp;

    mod = (modrm >> 6) & 3;
    rm = (modrm & 7) | ((s)->rex_b);
    if (mod == 3) {
        if (is_store) {
            if (reg != OR_TMP0)
                gen_op_mov_TN_reg(ot, 0, reg);
            gen_op_mov_reg_T0(ot, rm);
        } else {
            gen_op_mov_TN_reg(ot, 0, rm);
            if (reg != OR_TMP0)
                gen_op_mov_reg_T0(ot, reg);
        }
    } else {
        gen_lea_modrm(s, modrm, &opreg, &disp);
        if (is_store) {
            if (reg != OR_TMP0)
                gen_op_mov_TN_reg(ot, 0, reg);
            gen_op_st_T0_A0(ot + s->mem_index);
        } else {
            gen_op_ld_T0_A0(ot + s->mem_index);
            if (reg != OR_TMP0)
                gen_op_mov_reg_T0(ot, reg);
        }
    }
}

static __attribute__ (( always_inline )) __inline__ uint32_t insn_get(DisasContext *s, int ot)
{
    uint32_t ret;

    switch(ot) {
    case OT_BYTE:
        ret = ldub_code(s->pc);
        s->pc++;
        break;
    case OT_WORD:
        ret = lduw_code(s->pc);
        s->pc += 2;
        break;
    default:
    case OT_LONG:
        ret = ldl_code(s->pc);
        s->pc += 4;
        break;
    }
    return ret;
}

static __attribute__ (( always_inline )) __inline__ int insn_const_size(unsigned int ot)
{
    if (ot <= OT_LONG)
        return 1 << ot;
    else
        return 4;
}

static __attribute__ (( always_inline )) __inline__ void gen_goto_tb(DisasContext *s, int tb_num, target_ulong eip)
{
    TranslationBlock *tb;
    target_ulong pc;

    pc = s->cs_base + eip;
    tb = s->tb;

    if ((pc & ~((1 << 12) - 1)) == (tb->pc & ~((1 << 12) - 1)) ||
        (pc & ~((1 << 12) - 1)) == ((s->pc - 1) & ~((1 << 12) - 1))) {

        tcg_gen_goto_tb(tb_num);
        gen_jmp_im(eip);
        tcg_gen_exit_tb((long)tb + tb_num);
    } else {

        gen_jmp_im(eip);
        gen_eob(s);
    }
}

static __attribute__ (( always_inline )) __inline__ void gen_jcc(DisasContext *s, int b,
                           target_ulong val, target_ulong next_eip)
{
    int l1, l2, cc_op;

    cc_op = s->cc_op;
    gen_update_cc_op(s);
    if (s->jmp_opt) {
        l1 = gen_new_label();
        gen_jcc1(s, cc_op, b, l1);

        gen_goto_tb(s, 0, next_eip);

        gen_set_label(l1);
        gen_goto_tb(s, 1, val);
        s->is_jmp = 3;
    } else {

        l1 = gen_new_label();
        l2 = gen_new_label();
        gen_jcc1(s, cc_op, b, l1);

        gen_jmp_im(next_eip);
        tcg_gen_br(l2);

        gen_set_label(l1);
        gen_jmp_im(val);
        gen_set_label(l2);
        gen_eob(s);
    }
}

static void gen_setcc(DisasContext *s, int b)
{
    int inv, jcc_op, l1;
    TCGv_i64 t0;

    if (is_fast_jcc_case(s, b)) {


        t0 = tcg_temp_local_new_i64();
        tcg_gen_movi_i64(t0, 0);
        l1 = gen_new_label();
        gen_jcc1(s, s->cc_op, b ^ 1, l1);
        tcg_gen_movi_i64(t0, 1);
        gen_set_label(l1);
        tcg_gen_mov_i64(cpu_T[0], t0);
        tcg_temp_free_i64(t0);
    } else {



        inv = b & 1;
        jcc_op = (b >> 1) & 7;
        gen_setcc_slow_T0(s, jcc_op);
        if (inv) {
            tcg_gen_xori_i64(cpu_T[0], cpu_T[0], 1);
        }
    }
}

static __attribute__ (( always_inline )) __inline__ void gen_op_movl_T0_seg(int seg_reg)
{
    tcg_gen_ld32u_i64(cpu_T[0], cpu_env,
                     __builtin_offsetof (CPUX86State, segs[seg_reg].selector));
}

static __attribute__ (( always_inline )) __inline__ void gen_op_movl_seg_T0_vm(int seg_reg)
{
    tcg_gen_andi_i64(cpu_T[0], cpu_T[0], 0xffff);
    tcg_gen_st32_i64(cpu_T[0], cpu_env,
                    __builtin_offsetof (CPUX86State, segs[seg_reg].selector));
    tcg_gen_shli_i64(cpu_T[0], cpu_T[0], 4);
    tcg_gen_st_i64(cpu_T[0], cpu_env,
                  __builtin_offsetof (CPUX86State, segs[seg_reg].base));
}



static void gen_movl_seg_T0(DisasContext *s, int seg_reg, target_ulong cur_eip)
{
    if (s->pe && !s->vm86) {

        if (s->cc_op != CC_OP_DYNAMIC)
            gen_op_set_cc_op(s->cc_op);
        gen_jmp_im(cur_eip);
        tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
        gen_helper_load_seg(tcg_const_i32(seg_reg), cpu_tmp2_i32);




        if (seg_reg == 2 || (s->code32 && seg_reg < 4))
            s->is_jmp = 3;
    } else {
        gen_op_movl_seg_T0_vm(seg_reg);
        if (seg_reg == 2)
            s->is_jmp = 3;
    }
}

static __attribute__ (( always_inline )) __inline__ int svm_is_rep(int prefixes)
{
    return ((prefixes & (0x01 | 0x02)) ? 8 : 0);
}

static __attribute__ (( always_inline )) __inline__ void
gen_svm_check_intercept_param(DisasContext *s, target_ulong pc_start,
                              uint32_t type, uint64_t param)
{

    if (__builtin_expect(!!(!(s->flags & (1 << 21))), 1))
        return;
    if (s->cc_op != CC_OP_DYNAMIC)
        gen_op_set_cc_op(s->cc_op);
    gen_jmp_im(pc_start - s->cs_base);
    gen_helper_svm_check_intercept_param(tcg_const_i32(type),
                                         tcg_const_i64(param));
}

static __attribute__ (( always_inline )) __inline__ void
gen_svm_check_intercept(DisasContext *s, target_ulong pc_start, uint64_t type)
{
    gen_svm_check_intercept_param(s, pc_start, type, 0);
}

static __attribute__ (( always_inline )) __inline__ void gen_stack_update(DisasContext *s, int addend)
{

    if (((s)->code64)) {
        gen_op_add_reg_im(2, 4, addend);
    } else

    if (s->ss32) {
        gen_op_add_reg_im(1, 4, addend);
    } else {
        gen_op_add_reg_im(0, 4, addend);
    }
}


static void gen_push_T0(DisasContext *s)
{

    if (((s)->code64)) {
        gen_op_movq_A0_reg(4);
        if (s->dflag) {
            gen_op_addq_A0_im(-8);
            gen_op_st_T0_A0(OT_QUAD + s->mem_index);
        } else {
            gen_op_addq_A0_im(-2);
            gen_op_st_T0_A0(OT_WORD + s->mem_index);
        }
        gen_op_mov_reg_A0(2, 4);
    } else

    {
        gen_op_movl_A0_reg(4);
        if (!s->dflag)
            gen_op_addl_A0_im(-2);
        else
            gen_op_addl_A0_im(-4);
        if (s->ss32) {
            if (s->addseg) {
                tcg_gen_mov_i64(cpu_T[1], cpu_A0);
                gen_op_addl_A0_seg(2);
            }
        } else {
            gen_op_andl_A0_ffff();
            tcg_gen_mov_i64(cpu_T[1], cpu_A0);
            gen_op_addl_A0_seg(2);
        }
        gen_op_st_T0_A0(s->dflag + 1 + s->mem_index);
        if (s->ss32 && !s->addseg)
            gen_op_mov_reg_A0(1, 4);
        else
            gen_op_mov_reg_T1(s->ss32 + 1, 4);
    }
}



static void gen_push_T1(DisasContext *s)
{

    if (((s)->code64)) {
        gen_op_movq_A0_reg(4);
        if (s->dflag) {
            gen_op_addq_A0_im(-8);
            gen_op_st_T1_A0(OT_QUAD + s->mem_index);
        } else {
            gen_op_addq_A0_im(-2);
            gen_op_st_T0_A0(OT_WORD + s->mem_index);
        }
        gen_op_mov_reg_A0(2, 4);
    } else

    {
        gen_op_movl_A0_reg(4);
        if (!s->dflag)
            gen_op_addl_A0_im(-2);
        else
            gen_op_addl_A0_im(-4);
        if (s->ss32) {
            if (s->addseg) {
                gen_op_addl_A0_seg(2);
            }
        } else {
            gen_op_andl_A0_ffff();
            gen_op_addl_A0_seg(2);
        }
        gen_op_st_T1_A0(s->dflag + 1 + s->mem_index);

        if (s->ss32 && !s->addseg)
            gen_op_mov_reg_A0(1, 4);
        else
            gen_stack_update(s, (-2) << s->dflag);
    }
}


static void gen_pop_T0(DisasContext *s)
{

    if (((s)->code64)) {
        gen_op_movq_A0_reg(4);
        gen_op_ld_T0_A0((s->dflag ? OT_QUAD : OT_WORD) + s->mem_index);
    } else

    {
        gen_op_movl_A0_reg(4);
        if (s->ss32) {
            if (s->addseg)
                gen_op_addl_A0_seg(2);
        } else {
            gen_op_andl_A0_ffff();
            gen_op_addl_A0_seg(2);
        }
        gen_op_ld_T0_A0(s->dflag + 1 + s->mem_index);
    }
}

static void gen_pop_update(DisasContext *s)
{

    if (((s)->code64) && s->dflag) {
        gen_stack_update(s, 8);
    } else

    {
        gen_stack_update(s, 2 << s->dflag);
    }
}

static void gen_stack_A0(DisasContext *s)
{
    gen_op_movl_A0_reg(4);
    if (!s->ss32)
        gen_op_andl_A0_ffff();
    tcg_gen_mov_i64(cpu_T[1], cpu_A0);
    if (s->addseg)
        gen_op_addl_A0_seg(2);
}


static void gen_pusha(DisasContext *s)
{
    int i;
    gen_op_movl_A0_reg(4);
    gen_op_addl_A0_im(-16 << s->dflag);
    if (!s->ss32)
        gen_op_andl_A0_ffff();
    tcg_gen_mov_i64(cpu_T[1], cpu_A0);
    if (s->addseg)
        gen_op_addl_A0_seg(2);
    for(i = 0;i < 8; i++) {
        gen_op_mov_TN_reg(OT_LONG, 0, 7 - i);
        gen_op_st_T0_A0(OT_WORD + s->dflag + s->mem_index);
        gen_op_addl_A0_im(2 << s->dflag);
    }
    gen_op_mov_reg_T1(OT_WORD + s->ss32, 4);
}


static void gen_popa(DisasContext *s)
{
    int i;
    gen_op_movl_A0_reg(4);
    if (!s->ss32)
        gen_op_andl_A0_ffff();
    tcg_gen_mov_i64(cpu_T[1], cpu_A0);
    tcg_gen_addi_i64(cpu_T[1], cpu_T[1], 16 << s->dflag);
    if (s->addseg)
        gen_op_addl_A0_seg(2);
    for(i = 0;i < 8; i++) {

        if (i != 3) {
            gen_op_ld_T0_A0(OT_WORD + s->dflag + s->mem_index);
            gen_op_mov_reg_T0(OT_WORD + s->dflag, 7 - i);
        }
        gen_op_addl_A0_im(2 << s->dflag);
    }
    gen_op_mov_reg_T1(OT_WORD + s->ss32, 4);
}

static void gen_enter(DisasContext *s, int esp_addend, int level)
{
    int ot, opsize;

    level &= 0x1f;

    if (((s)->code64)) {
        ot = s->dflag ? OT_QUAD : OT_WORD;
        opsize = 1 << ot;

        gen_op_movl_A0_reg(4);
        gen_op_addq_A0_im(-opsize);
        tcg_gen_mov_i64(cpu_T[1], cpu_A0);


        gen_op_mov_TN_reg(OT_LONG, 0, 5);
        gen_op_st_T0_A0(ot + s->mem_index);
        if (level) {

            gen_helper_enter64_level(tcg_const_i32(level),
                                     tcg_const_i32((ot == OT_QUAD)),
                                     cpu_T[1]);
        }
        gen_op_mov_reg_T1(ot, 5);
        tcg_gen_addi_i64(cpu_T[1], cpu_T[1], -esp_addend + (-opsize * level));
        gen_op_mov_reg_T1(OT_QUAD, 4);
    } else

    {
        ot = s->dflag + OT_WORD;
        opsize = 2 << s->dflag;

        gen_op_movl_A0_reg(4);
        gen_op_addl_A0_im(-opsize);
        if (!s->ss32)
            gen_op_andl_A0_ffff();
        tcg_gen_mov_i64(cpu_T[1], cpu_A0);
        if (s->addseg)
            gen_op_addl_A0_seg(2);

        gen_op_mov_TN_reg(OT_LONG, 0, 5);
        gen_op_st_T0_A0(ot + s->mem_index);
        if (level) {

            gen_helper_enter_level(tcg_const_i32(level),
                                   tcg_const_i32(s->dflag),
                                   cpu_T[1]);
        }
        gen_op_mov_reg_T1(ot, 5);
        tcg_gen_addi_i64(cpu_T[1], cpu_T[1], -esp_addend + (-opsize * level));
        gen_op_mov_reg_T1(OT_WORD + s->ss32, 4);
    }
}

static void gen_exception(DisasContext *s, int trapno, target_ulong cur_eip)
{
    if (s->cc_op != CC_OP_DYNAMIC)
        gen_op_set_cc_op(s->cc_op);
    gen_jmp_im(cur_eip);
    gen_helper_raise_exception(tcg_const_i32(trapno));
    s->is_jmp = 3;
}



static void gen_interrupt(DisasContext *s, int intno,
                          target_ulong cur_eip, target_ulong next_eip)
{
    if (s->cc_op != CC_OP_DYNAMIC)
        gen_op_set_cc_op(s->cc_op);
    gen_jmp_im(cur_eip);
    gen_helper_raise_interrupt(tcg_const_i32(intno),
                               tcg_const_i32(next_eip - cur_eip));
    s->is_jmp = 3;
}

static void gen_debug(DisasContext *s, target_ulong cur_eip)
{
    if (s->cc_op != CC_OP_DYNAMIC)
        gen_op_set_cc_op(s->cc_op);
    gen_jmp_im(cur_eip);
    gen_helper_debug();
    s->is_jmp = 3;
}



static void gen_eob(DisasContext *s)
{
    if (s->cc_op != CC_OP_DYNAMIC)
        gen_op_set_cc_op(s->cc_op);
    if (s->tb->flags & (1 << 3)) {
        gen_helper_reset_inhibit_irq();
    }
    if (s->tb->flags & (1 << 16)) {
        gen_helper_reset_rf();
    }
    if (s->singlestep_enabled) {
        gen_helper_debug();
    } else if (s->tf) {
 gen_helper_single_step();
    } else {
        tcg_gen_exit_tb(0);
    }
    s->is_jmp = 3;
}



static void gen_jmp_tb(DisasContext *s, target_ulong eip, int tb_num)
{
    if (s->jmp_opt) {
        gen_update_cc_op(s);
        gen_goto_tb(s, tb_num, eip);
        s->is_jmp = 3;
    } else {
        gen_jmp_im(eip);
        gen_eob(s);
    }
}

static void gen_jmp(DisasContext *s, target_ulong eip)
{
    gen_jmp_tb(s, eip, 0);
}

static __attribute__ (( always_inline )) __inline__ void gen_ldq_env_A0(int idx, int offset)
{
    int mem_index = (idx >> 2) - 1;
    tcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0, mem_index);
    tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, offset);
}

static __attribute__ (( always_inline )) __inline__ void gen_stq_env_A0(int idx, int offset)
{
    int mem_index = (idx >> 2) - 1;
    tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, offset);
    tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0, mem_index);
}

static __attribute__ (( always_inline )) __inline__ void gen_ldo_env_A0(int idx, int offset)
{
    int mem_index = (idx >> 2) - 1;
    tcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0, mem_index);
    tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, offset + __builtin_offsetof (XMMReg, _q[0]));
    tcg_gen_addi_i64(cpu_tmp0, cpu_A0, 8);
    tcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_tmp0, mem_index);
    tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, offset + __builtin_offsetof (XMMReg, _q[1]));
}

static __attribute__ (( always_inline )) __inline__ void gen_sto_env_A0(int idx, int offset)
{
    int mem_index = (idx >> 2) - 1;
    tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, offset + __builtin_offsetof (XMMReg, _q[0]));
    tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0, mem_index);
    tcg_gen_addi_i64(cpu_tmp0, cpu_A0, 8);
    tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, offset + __builtin_offsetof (XMMReg, _q[1]));
    tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_tmp0, mem_index);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_movo(int d_offset, int s_offset)
{
    tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, s_offset);
    tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, d_offset);
    tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, s_offset + 8);
    tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, d_offset + 8);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_movq(int d_offset, int s_offset)
{
    tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, s_offset);
    tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, d_offset);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_movl(int d_offset, int s_offset)
{
    tcg_gen_ld_i32(cpu_tmp2_i32, cpu_env, s_offset);
    tcg_gen_st_i32(cpu_tmp2_i32, cpu_env, d_offset);
}

static __attribute__ (( always_inline )) __inline__ void gen_op_movq_env_0(int d_offset)
{
    tcg_gen_movi_i64(cpu_tmp1_i64, 0);
    tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, d_offset);
}
# 2783 "../../target-i386/translate.c"
static void *sse_op_table1[256][4] = {

    [0x0e] = { ((void *)2) },
    [0x0f] = { ((void *)2) },

    [0x10] = { ((void *)1), ((void *)1), ((void *)1), ((void *)1) },
    [0x11] = { ((void *)1), ((void *)1), ((void *)1), ((void *)1) },
    [0x12] = { ((void *)1), ((void *)1), ((void *)1), ((void *)1) },
    [0x13] = { ((void *)1), ((void *)1) },
    [0x14] = { gen_helper_punpckldq_xmm, gen_helper_punpcklqdq_xmm },
    [0x15] = { gen_helper_punpckhdq_xmm, gen_helper_punpckhqdq_xmm },
    [0x16] = { ((void *)1), ((void *)1), ((void *)1) },
    [0x17] = { ((void *)1), ((void *)1) },

    [0x28] = { ((void *)1), ((void *)1) },
    [0x29] = { ((void *)1), ((void *)1) },
    [0x2a] = { ((void *)1), ((void *)1), ((void *)1), ((void *)1) },
    [0x2b] = { ((void *)1), ((void *)1), ((void *)1), ((void *)1) },
    [0x2c] = { ((void *)1), ((void *)1), ((void *)1), ((void *)1) },
    [0x2d] = { ((void *)1), ((void *)1), ((void *)1), ((void *)1) },
    [0x2e] = { gen_helper_ucomiss, gen_helper_ucomisd },
    [0x2f] = { gen_helper_comiss, gen_helper_comisd },
    [0x50] = { ((void *)1), ((void *)1) },
    [0x51] = { gen_helper_sqrtps, gen_helper_sqrtpd, gen_helper_sqrtss, gen_helper_sqrtsd, },
    [0x52] = { gen_helper_rsqrtps, ((void *)0), gen_helper_rsqrtss, ((void *)0) },
    [0x53] = { gen_helper_rcpps, ((void *)0), gen_helper_rcpss, ((void *)0) },
    [0x54] = { gen_helper_pand_xmm, gen_helper_pand_xmm },
    [0x55] = { gen_helper_pandn_xmm, gen_helper_pandn_xmm },
    [0x56] = { gen_helper_por_xmm, gen_helper_por_xmm },
    [0x57] = { gen_helper_pxor_xmm, gen_helper_pxor_xmm },
    [0x58] = { gen_helper_addps, gen_helper_addpd, gen_helper_addss, gen_helper_addsd, },
    [0x59] = { gen_helper_mulps, gen_helper_mulpd, gen_helper_mulss, gen_helper_mulsd, },
    [0x5a] = { gen_helper_cvtps2pd, gen_helper_cvtpd2ps,
               gen_helper_cvtss2sd, gen_helper_cvtsd2ss },
    [0x5b] = { gen_helper_cvtdq2ps, gen_helper_cvtps2dq, gen_helper_cvttps2dq },
    [0x5c] = { gen_helper_subps, gen_helper_subpd, gen_helper_subss, gen_helper_subsd, },
    [0x5d] = { gen_helper_minps, gen_helper_minpd, gen_helper_minss, gen_helper_minsd, },
    [0x5e] = { gen_helper_divps, gen_helper_divpd, gen_helper_divss, gen_helper_divsd, },
    [0x5f] = { gen_helper_maxps, gen_helper_maxpd, gen_helper_maxss, gen_helper_maxsd, },

    [0xc2] = { gen_helper_cmpeqps, gen_helper_cmpeqpd, gen_helper_cmpeqss, gen_helper_cmpeqsd, },
    [0xc6] = { gen_helper_shufps, gen_helper_shufpd },

    [0x38] = { ((void *)1), ((void *)1), ((void *)0), ((void *)1) },
    [0x3a] = { ((void *)1), ((void *)1) },


    [0x60] = { gen_helper_punpcklbw_mmx, gen_helper_punpcklbw_xmm },
    [0x61] = { gen_helper_punpcklwd_mmx, gen_helper_punpcklwd_xmm },
    [0x62] = { gen_helper_punpckldq_mmx, gen_helper_punpckldq_xmm },
    [0x63] = { gen_helper_packsswb_mmx, gen_helper_packsswb_xmm },
    [0x64] = { gen_helper_pcmpgtb_mmx, gen_helper_pcmpgtb_xmm },
    [0x65] = { gen_helper_pcmpgtw_mmx, gen_helper_pcmpgtw_xmm },
    [0x66] = { gen_helper_pcmpgtl_mmx, gen_helper_pcmpgtl_xmm },
    [0x67] = { gen_helper_packuswb_mmx, gen_helper_packuswb_xmm },
    [0x68] = { gen_helper_punpckhbw_mmx, gen_helper_punpckhbw_xmm },
    [0x69] = { gen_helper_punpckhwd_mmx, gen_helper_punpckhwd_xmm },
    [0x6a] = { gen_helper_punpckhdq_mmx, gen_helper_punpckhdq_xmm },
    [0x6b] = { gen_helper_packssdw_mmx, gen_helper_packssdw_xmm },
    [0x6c] = { ((void *)0), gen_helper_punpcklqdq_xmm },
    [0x6d] = { ((void *)0), gen_helper_punpckhqdq_xmm },
    [0x6e] = { ((void *)1), ((void *)1) },
    [0x6f] = { ((void *)1), ((void *)1), ((void *)1) },
    [0x70] = { gen_helper_pshufw_mmx,
               gen_helper_pshufd_xmm,
               gen_helper_pshufhw_xmm,
               gen_helper_pshuflw_xmm },
    [0x71] = { ((void *)1), ((void *)1) },
    [0x72] = { ((void *)1), ((void *)1) },
    [0x73] = { ((void *)1), ((void *)1) },
    [0x74] = { gen_helper_pcmpeqb_mmx, gen_helper_pcmpeqb_xmm },
    [0x75] = { gen_helper_pcmpeqw_mmx, gen_helper_pcmpeqw_xmm },
    [0x76] = { gen_helper_pcmpeql_mmx, gen_helper_pcmpeql_xmm },
    [0x77] = { ((void *)2) },
    [0x78] = { ((void *)0), ((void *)1), ((void *)0), ((void *)1) },
    [0x79] = { ((void *)0), gen_helper_extrq_r, ((void *)0), gen_helper_insertq_r },
    [0x7c] = { ((void *)0), gen_helper_haddpd, ((void *)0), gen_helper_haddps },
    [0x7d] = { ((void *)0), gen_helper_hsubpd, ((void *)0), gen_helper_hsubps },
    [0x7e] = { ((void *)1), ((void *)1), ((void *)1) },
    [0x7f] = { ((void *)1), ((void *)1), ((void *)1) },
    [0xc4] = { ((void *)1), ((void *)1) },
    [0xc5] = { ((void *)1), ((void *)1) },
    [0xd0] = { ((void *)0), gen_helper_addsubpd, ((void *)0), gen_helper_addsubps },
    [0xd1] = { gen_helper_psrlw_mmx, gen_helper_psrlw_xmm },
    [0xd2] = { gen_helper_psrld_mmx, gen_helper_psrld_xmm },
    [0xd3] = { gen_helper_psrlq_mmx, gen_helper_psrlq_xmm },
    [0xd4] = { gen_helper_paddq_mmx, gen_helper_paddq_xmm },
    [0xd5] = { gen_helper_pmullw_mmx, gen_helper_pmullw_xmm },
    [0xd6] = { ((void *)0), ((void *)1), ((void *)1), ((void *)1) },
    [0xd7] = { ((void *)1), ((void *)1) },
    [0xd8] = { gen_helper_psubusb_mmx, gen_helper_psubusb_xmm },
    [0xd9] = { gen_helper_psubusw_mmx, gen_helper_psubusw_xmm },
    [0xda] = { gen_helper_pminub_mmx, gen_helper_pminub_xmm },
    [0xdb] = { gen_helper_pand_mmx, gen_helper_pand_xmm },
    [0xdc] = { gen_helper_paddusb_mmx, gen_helper_paddusb_xmm },
    [0xdd] = { gen_helper_paddusw_mmx, gen_helper_paddusw_xmm },
    [0xde] = { gen_helper_pmaxub_mmx, gen_helper_pmaxub_xmm },
    [0xdf] = { gen_helper_pandn_mmx, gen_helper_pandn_xmm },
    [0xe0] = { gen_helper_pavgb_mmx, gen_helper_pavgb_xmm },
    [0xe1] = { gen_helper_psraw_mmx, gen_helper_psraw_xmm },
    [0xe2] = { gen_helper_psrad_mmx, gen_helper_psrad_xmm },
    [0xe3] = { gen_helper_pavgw_mmx, gen_helper_pavgw_xmm },
    [0xe4] = { gen_helper_pmulhuw_mmx, gen_helper_pmulhuw_xmm },
    [0xe5] = { gen_helper_pmulhw_mmx, gen_helper_pmulhw_xmm },
    [0xe6] = { ((void *)0), gen_helper_cvttpd2dq, gen_helper_cvtdq2pd, gen_helper_cvtpd2dq },
    [0xe7] = { ((void *)1) , ((void *)1) },
    [0xe8] = { gen_helper_psubsb_mmx, gen_helper_psubsb_xmm },
    [0xe9] = { gen_helper_psubsw_mmx, gen_helper_psubsw_xmm },
    [0xea] = { gen_helper_pminsw_mmx, gen_helper_pminsw_xmm },
    [0xeb] = { gen_helper_por_mmx, gen_helper_por_xmm },
    [0xec] = { gen_helper_paddsb_mmx, gen_helper_paddsb_xmm },
    [0xed] = { gen_helper_paddsw_mmx, gen_helper_paddsw_xmm },
    [0xee] = { gen_helper_pmaxsw_mmx, gen_helper_pmaxsw_xmm },
    [0xef] = { gen_helper_pxor_mmx, gen_helper_pxor_xmm },
    [0xf0] = { ((void *)0), ((void *)0), ((void *)0), ((void *)1) },
    [0xf1] = { gen_helper_psllw_mmx, gen_helper_psllw_xmm },
    [0xf2] = { gen_helper_pslld_mmx, gen_helper_pslld_xmm },
    [0xf3] = { gen_helper_psllq_mmx, gen_helper_psllq_xmm },
    [0xf4] = { gen_helper_pmuludq_mmx, gen_helper_pmuludq_xmm },
    [0xf5] = { gen_helper_pmaddwd_mmx, gen_helper_pmaddwd_xmm },
    [0xf6] = { gen_helper_psadbw_mmx, gen_helper_psadbw_xmm },
    [0xf7] = { gen_helper_maskmov_mmx, gen_helper_maskmov_xmm },
    [0xf8] = { gen_helper_psubb_mmx, gen_helper_psubb_xmm },
    [0xf9] = { gen_helper_psubw_mmx, gen_helper_psubw_xmm },
    [0xfa] = { gen_helper_psubl_mmx, gen_helper_psubl_xmm },
    [0xfb] = { gen_helper_psubq_mmx, gen_helper_psubq_xmm },
    [0xfc] = { gen_helper_paddb_mmx, gen_helper_paddb_xmm },
    [0xfd] = { gen_helper_paddw_mmx, gen_helper_paddw_xmm },
    [0xfe] = { gen_helper_paddl_mmx, gen_helper_paddl_xmm },
};

static void *sse_op_table2[3 * 8][2] = {
    [0 + 2] = { gen_helper_psrlw_mmx, gen_helper_psrlw_xmm },
    [0 + 4] = { gen_helper_psraw_mmx, gen_helper_psraw_xmm },
    [0 + 6] = { gen_helper_psllw_mmx, gen_helper_psllw_xmm },
    [8 + 2] = { gen_helper_psrld_mmx, gen_helper_psrld_xmm },
    [8 + 4] = { gen_helper_psrad_mmx, gen_helper_psrad_xmm },
    [8 + 6] = { gen_helper_pslld_mmx, gen_helper_pslld_xmm },
    [16 + 2] = { gen_helper_psrlq_mmx, gen_helper_psrlq_xmm },
    [16 + 3] = { ((void *)0), gen_helper_psrldq_xmm },
    [16 + 6] = { gen_helper_psllq_mmx, gen_helper_psllq_xmm },
    [16 + 7] = { ((void *)0), gen_helper_pslldq_xmm },
};

static void *sse_op_table3[4 * 3] = {
    gen_helper_cvtsi2ss,
    gen_helper_cvtsi2sd,
    gen_helper_cvtsq2ss,
    gen_helper_cvtsq2sd,

    gen_helper_cvttss2si,
    gen_helper_cvttsd2si,
    gen_helper_cvttss2sq,
    gen_helper_cvttsd2sq,

    gen_helper_cvtss2si,
    gen_helper_cvtsd2si,
    gen_helper_cvtss2sq,
    gen_helper_cvtsd2sq,
};

static void *sse_op_table4[8][4] = {
    { gen_helper_cmpeqps, gen_helper_cmpeqpd, gen_helper_cmpeqss, gen_helper_cmpeqsd, },
    { gen_helper_cmpltps, gen_helper_cmpltpd, gen_helper_cmpltss, gen_helper_cmpltsd, },
    { gen_helper_cmpleps, gen_helper_cmplepd, gen_helper_cmpless, gen_helper_cmplesd, },
    { gen_helper_cmpunordps, gen_helper_cmpunordpd, gen_helper_cmpunordss, gen_helper_cmpunordsd, },
    { gen_helper_cmpneqps, gen_helper_cmpneqpd, gen_helper_cmpneqss, gen_helper_cmpneqsd, },
    { gen_helper_cmpnltps, gen_helper_cmpnltpd, gen_helper_cmpnltss, gen_helper_cmpnltsd, },
    { gen_helper_cmpnleps, gen_helper_cmpnlepd, gen_helper_cmpnless, gen_helper_cmpnlesd, },
    { gen_helper_cmpordps, gen_helper_cmpordpd, gen_helper_cmpordss, gen_helper_cmpordsd, },
};

static void *sse_op_table5[256] = {
    [0x0c] = gen_helper_pi2fw,
    [0x0d] = gen_helper_pi2fd,
    [0x1c] = gen_helper_pf2iw,
    [0x1d] = gen_helper_pf2id,
    [0x8a] = gen_helper_pfnacc,
    [0x8e] = gen_helper_pfpnacc,
    [0x90] = gen_helper_pfcmpge,
    [0x94] = gen_helper_pfmin,
    [0x96] = gen_helper_pfrcp,
    [0x97] = gen_helper_pfrsqrt,
    [0x9a] = gen_helper_pfsub,
    [0x9e] = gen_helper_pfadd,
    [0xa0] = gen_helper_pfcmpgt,
    [0xa4] = gen_helper_pfmax,
    [0xa6] = gen_helper_movq,
    [0xa7] = gen_helper_movq,
    [0xaa] = gen_helper_pfsubr,
    [0xae] = gen_helper_pfacc,
    [0xb0] = gen_helper_pfcmpeq,
    [0xb4] = gen_helper_pfmul,
    [0xb6] = gen_helper_movq,
    [0xb7] = gen_helper_pmulhrw_mmx,
    [0xbb] = gen_helper_pswapd,
    [0xbf] = gen_helper_pavgb_mmx
};

struct sse_op_helper_s {
    void *op[2]; uint32_t ext_mask;
};




static struct sse_op_helper_s sse_op_table6[256] = {
    [0x00] = { { gen_helper_pshufb_mmx, gen_helper_pshufb_xmm }, (1 << 9) },
    [0x01] = { { gen_helper_phaddw_mmx, gen_helper_phaddw_xmm }, (1 << 9) },
    [0x02] = { { gen_helper_phaddd_mmx, gen_helper_phaddd_xmm }, (1 << 9) },
    [0x03] = { { gen_helper_phaddsw_mmx, gen_helper_phaddsw_xmm }, (1 << 9) },
    [0x04] = { { gen_helper_pmaddubsw_mmx, gen_helper_pmaddubsw_xmm }, (1 << 9) },
    [0x05] = { { gen_helper_phsubw_mmx, gen_helper_phsubw_xmm }, (1 << 9) },
    [0x06] = { { gen_helper_phsubd_mmx, gen_helper_phsubd_xmm }, (1 << 9) },
    [0x07] = { { gen_helper_phsubsw_mmx, gen_helper_phsubsw_xmm }, (1 << 9) },
    [0x08] = { { gen_helper_psignb_mmx, gen_helper_psignb_xmm }, (1 << 9) },
    [0x09] = { { gen_helper_psignw_mmx, gen_helper_psignw_xmm }, (1 << 9) },
    [0x0a] = { { gen_helper_psignd_mmx, gen_helper_psignd_xmm }, (1 << 9) },
    [0x0b] = { { gen_helper_pmulhrsw_mmx, gen_helper_pmulhrsw_xmm }, (1 << 9) },
    [0x10] = { { ((void *)0), gen_helper_pblendvb_xmm }, (1 << 19) },
    [0x14] = { { ((void *)0), gen_helper_blendvps_xmm }, (1 << 19) },
    [0x15] = { { ((void *)0), gen_helper_blendvpd_xmm }, (1 << 19) },
    [0x17] = { { ((void *)0), gen_helper_ptest_xmm }, (1 << 19) },
    [0x1c] = { { gen_helper_pabsb_mmx, gen_helper_pabsb_xmm }, (1 << 9) },
    [0x1d] = { { gen_helper_pabsw_mmx, gen_helper_pabsw_xmm }, (1 << 9) },
    [0x1e] = { { gen_helper_pabsd_mmx, gen_helper_pabsd_xmm }, (1 << 9) },
    [0x20] = { { ((void *)0), gen_helper_pmovsxbw_xmm }, (1 << 19) },
    [0x21] = { { ((void *)0), gen_helper_pmovsxbd_xmm }, (1 << 19) },
    [0x22] = { { ((void *)0), gen_helper_pmovsxbq_xmm }, (1 << 19) },
    [0x23] = { { ((void *)0), gen_helper_pmovsxwd_xmm }, (1 << 19) },
    [0x24] = { { ((void *)0), gen_helper_pmovsxwq_xmm }, (1 << 19) },
    [0x25] = { { ((void *)0), gen_helper_pmovsxdq_xmm }, (1 << 19) },
    [0x28] = { { ((void *)0), gen_helper_pmuldq_xmm }, (1 << 19) },
    [0x29] = { { ((void *)0), gen_helper_pcmpeqq_xmm }, (1 << 19) },
    [0x2a] = { { ((void *)0), ((void *)1) }, (1 << 19) },
    [0x2b] = { { ((void *)0), gen_helper_packusdw_xmm }, (1 << 19) },
    [0x30] = { { ((void *)0), gen_helper_pmovzxbw_xmm }, (1 << 19) },
    [0x31] = { { ((void *)0), gen_helper_pmovzxbd_xmm }, (1 << 19) },
    [0x32] = { { ((void *)0), gen_helper_pmovzxbq_xmm }, (1 << 19) },
    [0x33] = { { ((void *)0), gen_helper_pmovzxwd_xmm }, (1 << 19) },
    [0x34] = { { ((void *)0), gen_helper_pmovzxwq_xmm }, (1 << 19) },
    [0x35] = { { ((void *)0), gen_helper_pmovzxdq_xmm }, (1 << 19) },
    [0x37] = { { ((void *)0), gen_helper_pcmpgtq_xmm }, (1 << 20) },
    [0x38] = { { ((void *)0), gen_helper_pminsb_xmm }, (1 << 19) },
    [0x39] = { { ((void *)0), gen_helper_pminsd_xmm }, (1 << 19) },
    [0x3a] = { { ((void *)0), gen_helper_pminuw_xmm }, (1 << 19) },
    [0x3b] = { { ((void *)0), gen_helper_pminud_xmm }, (1 << 19) },
    [0x3c] = { { ((void *)0), gen_helper_pmaxsb_xmm }, (1 << 19) },
    [0x3d] = { { ((void *)0), gen_helper_pmaxsd_xmm }, (1 << 19) },
    [0x3e] = { { ((void *)0), gen_helper_pmaxuw_xmm }, (1 << 19) },
    [0x3f] = { { ((void *)0), gen_helper_pmaxud_xmm }, (1 << 19) },
    [0x40] = { { ((void *)0), gen_helper_pmulld_xmm }, (1 << 19) },
    [0x41] = { { ((void *)0), gen_helper_phminposuw_xmm }, (1 << 19) },
};

static struct sse_op_helper_s sse_op_table7[256] = {
    [0x08] = { { ((void *)0), gen_helper_roundps_xmm }, (1 << 19) },
    [0x09] = { { ((void *)0), gen_helper_roundpd_xmm }, (1 << 19) },
    [0x0a] = { { ((void *)0), gen_helper_roundss_xmm }, (1 << 19) },
    [0x0b] = { { ((void *)0), gen_helper_roundsd_xmm }, (1 << 19) },
    [0x0c] = { { ((void *)0), gen_helper_blendps_xmm }, (1 << 19) },
    [0x0d] = { { ((void *)0), gen_helper_blendpd_xmm }, (1 << 19) },
    [0x0e] = { { ((void *)0), gen_helper_pblendw_xmm }, (1 << 19) },
    [0x0f] = { { gen_helper_palignr_mmx, gen_helper_palignr_xmm }, (1 << 9) },
    [0x14] = { { ((void *)0), ((void *)1) }, (1 << 19) },
    [0x15] = { { ((void *)0), ((void *)1) }, (1 << 19) },
    [0x16] = { { ((void *)0), ((void *)1) }, (1 << 19) },
    [0x17] = { { ((void *)0), ((void *)1) }, (1 << 19) },
    [0x20] = { { ((void *)0), ((void *)1) }, (1 << 19) },
    [0x21] = { { ((void *)0), ((void *)1) }, (1 << 19) },
    [0x22] = { { ((void *)0), ((void *)1) }, (1 << 19) },
    [0x40] = { { ((void *)0), gen_helper_dpps_xmm }, (1 << 19) },
    [0x41] = { { ((void *)0), gen_helper_dppd_xmm }, (1 << 19) },
    [0x42] = { { ((void *)0), gen_helper_mpsadbw_xmm }, (1 << 19) },
    [0x60] = { { ((void *)0), gen_helper_pcmpestrm_xmm }, (1 << 20) },
    [0x61] = { { ((void *)0), gen_helper_pcmpestri_xmm }, (1 << 20) },
    [0x62] = { { ((void *)0), gen_helper_pcmpistrm_xmm }, (1 << 20) },
    [0x63] = { { ((void *)0), gen_helper_pcmpistri_xmm }, (1 << 20) },
};

static void gen_sse(DisasContext *s, int b, target_ulong pc_start, int rex_r)
{
    int b1, op1_offset, op2_offset, is_xmm, val, ot;
    int modrm, mod, rm, reg, reg_addr, offset_addr;
    void *sse_op2;

    b &= 0xff;
    if (s->prefix & 0x08)
        b1 = 1;
    else if (s->prefix & 0x01)
        b1 = 2;
    else if (s->prefix & 0x02)
        b1 = 3;
    else
        b1 = 0;
    sse_op2 = sse_op_table1[b][b1];
    if (!sse_op2)
        goto illegal_op;
    if ((b <= 0x5f && b >= 0x10) || b == 0xc6 || b == 0xc2) {
        is_xmm = 1;
    } else {
        if (b1 == 0) {

            is_xmm = 0;
        } else {
            is_xmm = 1;
        }
    }

    if (s->flags & (1 << 11)) {
        gen_exception(s, 7, pc_start - s->cs_base);
        return;
    }
    if (s->flags & (1 << 10)) {
    illegal_op:
        gen_exception(s, 6, pc_start - s->cs_base);
        return;
    }
    if (is_xmm && !(s->flags & (1 << 22)))
        if ((b != 0x38 && b != 0x3a) || (s->prefix & 0x08))
            goto illegal_op;
    if (b == 0x0e) {
        if (!(s->cpuid_ext2_features & (1 << 31)))
            goto illegal_op;

        gen_helper_emms();
        return;
    }
    if (b == 0x77) {

        gen_helper_emms();
        return;
    }


    if (!is_xmm) {
        gen_helper_enter_mmx();
    }

    modrm = ldub_code(s->pc++);
    reg = ((modrm >> 3) & 7);
    if (is_xmm)
        reg |= rex_r;
    mod = (modrm >> 6) & 3;
    if (sse_op2 == ((void *)1)) {
        b |= (b1 << 8);
        switch(b) {
        case 0x0e7:
            if (mod == 3)
                goto illegal_op;
            gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
            gen_stq_env_A0(s->mem_index, __builtin_offsetof (CPUX86State, fpregs[reg].mmx));
            break;
        case 0x1e7:
        case 0x02b:
        case 0x12b:
            if (mod == 3)
                goto illegal_op;
            gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
            gen_sto_env_A0(s->mem_index, __builtin_offsetof (CPUX86State, xmm_regs[reg]));
            break;
        case 0x3f0:
            if (mod == 3)
                goto illegal_op;
            gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
            gen_ldo_env_A0(s->mem_index, __builtin_offsetof (CPUX86State, xmm_regs[reg]));
            break;
        case 0x22b:
        case 0x32b:
            if (mod == 3)
                goto illegal_op;
            gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
            if (b1 & 1) {
                gen_stq_env_A0(s->mem_index, __builtin_offsetof (CPUX86State, xmm_regs[reg])
                                  );
            } else {
                tcg_gen_ld32u_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, xmm_regs[reg]._l[0])
                                           );
                gen_op_st_T0_A0(OT_LONG + s->mem_index);
            }
            break;
        case 0x6e:

            if (s->dflag == 2) {
                gen_ldst_modrm(s, modrm, OT_QUAD, OR_TMP0, 0);
                tcg_gen_st_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, fpregs[reg].mmx));
            } else

            {
                gen_ldst_modrm(s, modrm, OT_LONG, OR_TMP0, 0);
                tcg_gen_addi_i32(cpu_ptr0, cpu_env,
                                 __builtin_offsetof (CPUX86State, fpregs[reg].mmx));
                tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
                gen_helper_movl_mm_T0_mmx(cpu_ptr0, cpu_tmp2_i32);
            }
            break;
        case 0x16e:

            if (s->dflag == 2) {
                gen_ldst_modrm(s, modrm, OT_QUAD, OR_TMP0, 0);
                tcg_gen_addi_i32(cpu_ptr0, cpu_env,
                                 __builtin_offsetof (CPUX86State, xmm_regs[reg]));
                gen_helper_movq_mm_T0_xmm(cpu_ptr0, cpu_T[0]);
            } else

            {
                gen_ldst_modrm(s, modrm, OT_LONG, OR_TMP0, 0);
                tcg_gen_addi_i32(cpu_ptr0, cpu_env,
                                 __builtin_offsetof (CPUX86State, xmm_regs[reg]));
                tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
                gen_helper_movl_mm_T0_xmm(cpu_ptr0, cpu_tmp2_i32);
            }
            break;
        case 0x6f:
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                gen_ldq_env_A0(s->mem_index, __builtin_offsetof (CPUX86State, fpregs[reg].mmx));
            } else {
                rm = (modrm & 7);
                tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env,
                               __builtin_offsetof (CPUX86State, fpregs[rm].mmx));
                tcg_gen_st_i64(cpu_tmp1_i64, cpu_env,
                               __builtin_offsetof (CPUX86State, fpregs[reg].mmx));
            }
            break;
        case 0x010:
        case 0x110:
        case 0x028:
        case 0x128:
        case 0x16f:
        case 0x26f:
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                gen_ldo_env_A0(s->mem_index, __builtin_offsetof (CPUX86State, xmm_regs[reg]));
            } else {
                rm = (modrm & 7) | ((s)->rex_b);
                gen_op_movo(__builtin_offsetof (CPUX86State, xmm_regs[reg]),
                            __builtin_offsetof (CPUX86State, xmm_regs[rm]));
            }
            break;
        case 0x210:
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                gen_op_ld_T0_A0(OT_LONG + s->mem_index);
                tcg_gen_st32_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, xmm_regs[reg]._l[0]));
                gen_op_movl_T0_0();
                tcg_gen_st32_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, xmm_regs[reg]._l[1]));
                tcg_gen_st32_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, xmm_regs[reg]._l[2]));
                tcg_gen_st32_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, xmm_regs[reg]._l[3]));
            } else {
                rm = (modrm & 7) | ((s)->rex_b);
                gen_op_movl(__builtin_offsetof (CPUX86State, xmm_regs[reg]._l[0]),
                            __builtin_offsetof (CPUX86State, xmm_regs[rm]._l[0]));
            }
            break;
        case 0x310:
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                gen_ldq_env_A0(s->mem_index, __builtin_offsetof (CPUX86State, xmm_regs[reg]._q[0]));
                gen_op_movl_T0_0();
                tcg_gen_st32_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, xmm_regs[reg]._l[2]));
                tcg_gen_st32_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, xmm_regs[reg]._l[3]));
            } else {
                rm = (modrm & 7) | ((s)->rex_b);
                gen_op_movq(__builtin_offsetof (CPUX86State, xmm_regs[reg]._q[0]),
                            __builtin_offsetof (CPUX86State, xmm_regs[rm]._q[0]));
            }
            break;
        case 0x012:
        case 0x112:
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                gen_ldq_env_A0(s->mem_index, __builtin_offsetof (CPUX86State, xmm_regs[reg]._q[0]));
            } else {

                rm = (modrm & 7) | ((s)->rex_b);
                gen_op_movq(__builtin_offsetof (CPUX86State, xmm_regs[reg]._q[0]),
                            __builtin_offsetof (CPUX86State, xmm_regs[rm]._q[1]));
            }
            break;
        case 0x212:
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                gen_ldo_env_A0(s->mem_index, __builtin_offsetof (CPUX86State, xmm_regs[reg]));
            } else {
                rm = (modrm & 7) | ((s)->rex_b);
                gen_op_movl(__builtin_offsetof (CPUX86State, xmm_regs[reg]._l[0]),
                            __builtin_offsetof (CPUX86State, xmm_regs[rm]._l[0]));
                gen_op_movl(__builtin_offsetof (CPUX86State, xmm_regs[reg]._l[2]),
                            __builtin_offsetof (CPUX86State, xmm_regs[rm]._l[2]));
            }
            gen_op_movl(__builtin_offsetof (CPUX86State, xmm_regs[reg]._l[1]),
                        __builtin_offsetof (CPUX86State, xmm_regs[reg]._l[0]));
            gen_op_movl(__builtin_offsetof (CPUX86State, xmm_regs[reg]._l[3]),
                        __builtin_offsetof (CPUX86State, xmm_regs[reg]._l[2]));
            break;
        case 0x312:
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                gen_ldq_env_A0(s->mem_index, __builtin_offsetof (CPUX86State, xmm_regs[reg]._q[0]));
            } else {
                rm = (modrm & 7) | ((s)->rex_b);
                gen_op_movq(__builtin_offsetof (CPUX86State, xmm_regs[reg]._q[0]),
                            __builtin_offsetof (CPUX86State, xmm_regs[rm]._q[0]));
            }
            gen_op_movq(__builtin_offsetof (CPUX86State, xmm_regs[reg]._q[1]),
                        __builtin_offsetof (CPUX86State, xmm_regs[reg]._q[0]));
            break;
        case 0x016:
        case 0x116:
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                gen_ldq_env_A0(s->mem_index, __builtin_offsetof (CPUX86State, xmm_regs[reg]._q[1]));
            } else {

                rm = (modrm & 7) | ((s)->rex_b);
                gen_op_movq(__builtin_offsetof (CPUX86State, xmm_regs[reg]._q[1]),
                            __builtin_offsetof (CPUX86State, xmm_regs[rm]._q[0]));
            }
            break;
        case 0x216:
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                gen_ldo_env_A0(s->mem_index, __builtin_offsetof (CPUX86State, xmm_regs[reg]));
            } else {
                rm = (modrm & 7) | ((s)->rex_b);
                gen_op_movl(__builtin_offsetof (CPUX86State, xmm_regs[reg]._l[1]),
                            __builtin_offsetof (CPUX86State, xmm_regs[rm]._l[1]));
                gen_op_movl(__builtin_offsetof (CPUX86State, xmm_regs[reg]._l[3]),
                            __builtin_offsetof (CPUX86State, xmm_regs[rm]._l[3]));
            }
            gen_op_movl(__builtin_offsetof (CPUX86State, xmm_regs[reg]._l[0]),
                        __builtin_offsetof (CPUX86State, xmm_regs[reg]._l[1]));
            gen_op_movl(__builtin_offsetof (CPUX86State, xmm_regs[reg]._l[2]),
                        __builtin_offsetof (CPUX86State, xmm_regs[reg]._l[3]));
            break;
        case 0x178:
        case 0x378:
            {
                int bit_index, field_length;

                if (b1 == 1 && reg != 0)
                    goto illegal_op;
                field_length = ldub_code(s->pc++) & 0x3F;
                bit_index = ldub_code(s->pc++) & 0x3F;
                tcg_gen_addi_i32(cpu_ptr0, cpu_env,
                    __builtin_offsetof (CPUX86State, xmm_regs[reg]));
                if (b1 == 1)
                    gen_helper_extrq_i(cpu_ptr0, tcg_const_i32(bit_index),
                        tcg_const_i32(field_length));
                else
                    gen_helper_insertq_i(cpu_ptr0, tcg_const_i32(bit_index),
                        tcg_const_i32(field_length));
            }
            break;
        case 0x7e:

            if (s->dflag == 2) {
                tcg_gen_ld_i64(cpu_T[0], cpu_env,
                               __builtin_offsetof (CPUX86State, fpregs[reg].mmx));
                gen_ldst_modrm(s, modrm, OT_QUAD, OR_TMP0, 1);
            } else

            {
                tcg_gen_ld32u_i64(cpu_T[0], cpu_env,
                                 __builtin_offsetof (CPUX86State, fpregs[reg].mmx._l[0]));
                gen_ldst_modrm(s, modrm, OT_LONG, OR_TMP0, 1);
            }
            break;
        case 0x17e:

            if (s->dflag == 2) {
                tcg_gen_ld_i64(cpu_T[0], cpu_env,
                               __builtin_offsetof (CPUX86State, xmm_regs[reg]._q[0]));
                gen_ldst_modrm(s, modrm, OT_QUAD, OR_TMP0, 1);
            } else

            {
                tcg_gen_ld32u_i64(cpu_T[0], cpu_env,
                                 __builtin_offsetof (CPUX86State, xmm_regs[reg]._l[0]));
                gen_ldst_modrm(s, modrm, OT_LONG, OR_TMP0, 1);
            }
            break;
        case 0x27e:
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                gen_ldq_env_A0(s->mem_index, __builtin_offsetof (CPUX86State, xmm_regs[reg]._q[0]));
            } else {
                rm = (modrm & 7) | ((s)->rex_b);
                gen_op_movq(__builtin_offsetof (CPUX86State, xmm_regs[reg]._q[0]),
                            __builtin_offsetof (CPUX86State, xmm_regs[rm]._q[0]));
            }
            gen_op_movq_env_0(__builtin_offsetof (CPUX86State, xmm_regs[reg]._q[1]));
            break;
        case 0x7f:
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                gen_stq_env_A0(s->mem_index, __builtin_offsetof (CPUX86State, fpregs[reg].mmx));
            } else {
                rm = (modrm & 7);
                gen_op_movq(__builtin_offsetof (CPUX86State, fpregs[rm].mmx),
                            __builtin_offsetof (CPUX86State, fpregs[reg].mmx));
            }
            break;
        case 0x011:
        case 0x111:
        case 0x029:
        case 0x129:
        case 0x17f:
        case 0x27f:
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                gen_sto_env_A0(s->mem_index, __builtin_offsetof (CPUX86State, xmm_regs[reg]));
            } else {
                rm = (modrm & 7) | ((s)->rex_b);
                gen_op_movo(__builtin_offsetof (CPUX86State, xmm_regs[rm]),
                            __builtin_offsetof (CPUX86State, xmm_regs[reg]));
            }
            break;
        case 0x211:
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                tcg_gen_ld32u_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, xmm_regs[reg]._l[0]));
                gen_op_st_T0_A0(OT_LONG + s->mem_index);
            } else {
                rm = (modrm & 7) | ((s)->rex_b);
                gen_op_movl(__builtin_offsetof (CPUX86State, xmm_regs[rm]._l[0]),
                            __builtin_offsetof (CPUX86State, xmm_regs[reg]._l[0]));
            }
            break;
        case 0x311:
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                gen_stq_env_A0(s->mem_index, __builtin_offsetof (CPUX86State, xmm_regs[reg]._q[0]));
            } else {
                rm = (modrm & 7) | ((s)->rex_b);
                gen_op_movq(__builtin_offsetof (CPUX86State, xmm_regs[rm]._q[0]),
                            __builtin_offsetof (CPUX86State, xmm_regs[reg]._q[0]));
            }
            break;
        case 0x013:
        case 0x113:
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                gen_stq_env_A0(s->mem_index, __builtin_offsetof (CPUX86State, xmm_regs[reg]._q[0]));
            } else {
                goto illegal_op;
            }
            break;
        case 0x017:
        case 0x117:
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                gen_stq_env_A0(s->mem_index, __builtin_offsetof (CPUX86State, xmm_regs[reg]._q[1]));
            } else {
                goto illegal_op;
            }
            break;
        case 0x71:
        case 0x72:
        case 0x73:
        case 0x171:
        case 0x172:
        case 0x173:
            if (b1 >= 2) {
         goto illegal_op;
            }
            val = ldub_code(s->pc++);
            if (is_xmm) {
                gen_op_movl_T0_im(val);
                tcg_gen_st32_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, xmm_t0._l[0]));
                gen_op_movl_T0_0();
                tcg_gen_st32_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, xmm_t0._l[1]));
                op1_offset = __builtin_offsetof (CPUX86State, xmm_t0);
            } else {
                gen_op_movl_T0_im(val);
                tcg_gen_st32_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, mmx_t0._l[0]));
                gen_op_movl_T0_0();
                tcg_gen_st32_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, mmx_t0._l[1]));
                op1_offset = __builtin_offsetof (CPUX86State, mmx_t0);
            }
            sse_op2 = sse_op_table2[((b - 1) & 3) * 8 + (((modrm >> 3)) & 7)][b1];
            if (!sse_op2)
                goto illegal_op;
            if (is_xmm) {
                rm = (modrm & 7) | ((s)->rex_b);
                op2_offset = __builtin_offsetof (CPUX86State, xmm_regs[rm]);
            } else {
                rm = (modrm & 7);
                op2_offset = __builtin_offsetof (CPUX86State, fpregs[rm].mmx);
            }
            tcg_gen_addi_i32(cpu_ptr0, cpu_env, op2_offset);
            tcg_gen_addi_i32(cpu_ptr1, cpu_env, op1_offset);
            ((void (*)(TCGv_i32, TCGv_i32))sse_op2)(cpu_ptr0, cpu_ptr1);
            break;
        case 0x050:
            rm = (modrm & 7) | ((s)->rex_b);
            tcg_gen_addi_i32(cpu_ptr0, cpu_env,
                             __builtin_offsetof (CPUX86State, xmm_regs[rm]));
            gen_helper_movmskps(cpu_tmp2_i32, cpu_ptr0);
            tcg_gen_extu_i32_i64(cpu_T[0], cpu_tmp2_i32);
            gen_op_mov_reg_T0(OT_LONG, reg);
            break;
        case 0x150:
            rm = (modrm & 7) | ((s)->rex_b);
            tcg_gen_addi_i32(cpu_ptr0, cpu_env,
                             __builtin_offsetof (CPUX86State, xmm_regs[rm]));
            gen_helper_movmskpd(cpu_tmp2_i32, cpu_ptr0);
            tcg_gen_extu_i32_i64(cpu_T[0], cpu_tmp2_i32);
            gen_op_mov_reg_T0(OT_LONG, reg);
            break;
        case 0x02a:
        case 0x12a:
            gen_helper_enter_mmx();
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                op2_offset = __builtin_offsetof (CPUX86State, mmx_t0);
                gen_ldq_env_A0(s->mem_index, op2_offset);
            } else {
                rm = (modrm & 7);
                op2_offset = __builtin_offsetof (CPUX86State, fpregs[rm].mmx);
            }
            op1_offset = __builtin_offsetof (CPUX86State, xmm_regs[reg]);
            tcg_gen_addi_i32(cpu_ptr0, cpu_env, op1_offset);
            tcg_gen_addi_i32(cpu_ptr1, cpu_env, op2_offset);
            switch(b >> 8) {
            case 0x0:
                gen_helper_cvtpi2ps(cpu_ptr0, cpu_ptr1);
                break;
            default:
            case 0x1:
                gen_helper_cvtpi2pd(cpu_ptr0, cpu_ptr1);
                break;
            }
            break;
        case 0x22a:
        case 0x32a:
            ot = (s->dflag == 2) ? OT_QUAD : OT_LONG;
            gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
            op1_offset = __builtin_offsetof (CPUX86State, xmm_regs[reg]);
            tcg_gen_addi_i32(cpu_ptr0, cpu_env, op1_offset);
            sse_op2 = sse_op_table3[(s->dflag == 2) * 2 + ((b >> 8) - 2)];
            if (ot == OT_LONG) {
                tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
                ((void (*)(TCGv_i32, TCGv_i32))sse_op2)(cpu_ptr0, cpu_tmp2_i32);
            } else {
                ((void (*)(TCGv_i32, TCGv_i64))sse_op2)(cpu_ptr0, cpu_T[0]);
            }
            break;
        case 0x02c:
        case 0x12c:
        case 0x02d:
        case 0x12d:
            gen_helper_enter_mmx();
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                op2_offset = __builtin_offsetof (CPUX86State, xmm_t0);
                gen_ldo_env_A0(s->mem_index, op2_offset);
            } else {
                rm = (modrm & 7) | ((s)->rex_b);
                op2_offset = __builtin_offsetof (CPUX86State, xmm_regs[rm]);
            }
            op1_offset = __builtin_offsetof (CPUX86State, fpregs[reg & 7].mmx);
            tcg_gen_addi_i32(cpu_ptr0, cpu_env, op1_offset);
            tcg_gen_addi_i32(cpu_ptr1, cpu_env, op2_offset);
            switch(b) {
            case 0x02c:
                gen_helper_cvttps2pi(cpu_ptr0, cpu_ptr1);
                break;
            case 0x12c:
                gen_helper_cvttpd2pi(cpu_ptr0, cpu_ptr1);
                break;
            case 0x02d:
                gen_helper_cvtps2pi(cpu_ptr0, cpu_ptr1);
                break;
            case 0x12d:
                gen_helper_cvtpd2pi(cpu_ptr0, cpu_ptr1);
                break;
            }
            break;
        case 0x22c:
        case 0x32c:
        case 0x22d:
        case 0x32d:
            ot = (s->dflag == 2) ? OT_QUAD : OT_LONG;
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                if ((b >> 8) & 1) {
                    gen_ldq_env_A0(s->mem_index, __builtin_offsetof (CPUX86State, xmm_t0._q[0]));
                } else {
                    gen_op_ld_T0_A0(OT_LONG + s->mem_index);
                    tcg_gen_st32_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, xmm_t0._l[0]));
                }
                op2_offset = __builtin_offsetof (CPUX86State, xmm_t0);
            } else {
                rm = (modrm & 7) | ((s)->rex_b);
                op2_offset = __builtin_offsetof (CPUX86State, xmm_regs[rm]);
            }
            sse_op2 = sse_op_table3[(s->dflag == 2) * 2 + ((b >> 8) - 2) + 4 +
                                    (b & 1) * 4];
            tcg_gen_addi_i32(cpu_ptr0, cpu_env, op2_offset);
            if (ot == OT_LONG) {
                ((void (*)(TCGv_i32, TCGv_i32))sse_op2)(cpu_tmp2_i32, cpu_ptr0);
                tcg_gen_extu_i32_i64(cpu_T[0], cpu_tmp2_i32);
            } else {
                ((void (*)(TCGv_i64, TCGv_i32))sse_op2)(cpu_T[0], cpu_ptr0);
            }
            gen_op_mov_reg_T0(ot, reg);
            break;
        case 0xc4:
        case 0x1c4:
            s->rip_offset = 1;
            gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
            val = ldub_code(s->pc++);
            if (b1) {
                val &= 7;
                tcg_gen_st16_i64(cpu_T[0], cpu_env,
                                __builtin_offsetof (CPUX86State, xmm_regs[reg]._w[val]));
            } else {
                val &= 3;
                tcg_gen_st16_i64(cpu_T[0], cpu_env,
                                __builtin_offsetof (CPUX86State, fpregs[reg].mmx._w[val]));
            }
            break;
        case 0xc5:
        case 0x1c5:
            if (mod != 3)
                goto illegal_op;
            ot = (s->dflag == 2) ? OT_QUAD : OT_LONG;
            val = ldub_code(s->pc++);
            if (b1) {
                val &= 7;
                rm = (modrm & 7) | ((s)->rex_b);
                tcg_gen_ld16u_i64(cpu_T[0], cpu_env,
                                 __builtin_offsetof (CPUX86State, xmm_regs[rm]._w[val]));
            } else {
                val &= 3;
                rm = (modrm & 7);
                tcg_gen_ld16u_i64(cpu_T[0], cpu_env,
                                __builtin_offsetof (CPUX86State, fpregs[rm].mmx._w[val]));
            }
            reg = ((modrm >> 3) & 7) | rex_r;
            gen_op_mov_reg_T0(ot, reg);
            break;
        case 0x1d6:
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                gen_stq_env_A0(s->mem_index, __builtin_offsetof (CPUX86State, xmm_regs[reg]._q[0]));
            } else {
                rm = (modrm & 7) | ((s)->rex_b);
                gen_op_movq(__builtin_offsetof (CPUX86State, xmm_regs[rm]._q[0]),
                            __builtin_offsetof (CPUX86State, xmm_regs[reg]._q[0]));
                gen_op_movq_env_0(__builtin_offsetof (CPUX86State, xmm_regs[rm]._q[1]));
            }
            break;
        case 0x2d6:
            gen_helper_enter_mmx();
            rm = (modrm & 7);
            gen_op_movq(__builtin_offsetof (CPUX86State, xmm_regs[reg]._q[0]),
                        __builtin_offsetof (CPUX86State, fpregs[rm].mmx));
            gen_op_movq_env_0(__builtin_offsetof (CPUX86State, xmm_regs[reg]._q[1]));
            break;
        case 0x3d6:
            gen_helper_enter_mmx();
            rm = (modrm & 7) | ((s)->rex_b);
            gen_op_movq(__builtin_offsetof (CPUX86State, fpregs[reg & 7].mmx),
                        __builtin_offsetof (CPUX86State, xmm_regs[rm]._q[0]));
            break;
        case 0xd7:
        case 0x1d7:
            if (mod != 3)
                goto illegal_op;
            if (b1) {
                rm = (modrm & 7) | ((s)->rex_b);
                tcg_gen_addi_i32(cpu_ptr0, cpu_env, __builtin_offsetof (CPUX86State, xmm_regs[rm]));
                gen_helper_pmovmskb_xmm(cpu_tmp2_i32, cpu_ptr0);
            } else {
                rm = (modrm & 7);
                tcg_gen_addi_i32(cpu_ptr0, cpu_env, __builtin_offsetof (CPUX86State, fpregs[rm].mmx));
                gen_helper_pmovmskb_mmx(cpu_tmp2_i32, cpu_ptr0);
            }
            tcg_gen_extu_i32_i64(cpu_T[0], cpu_tmp2_i32);
            reg = ((modrm >> 3) & 7) | rex_r;
            gen_op_mov_reg_T0(OT_LONG, reg);
            break;
        case 0x138:
            if (s->prefix & 0x02)
                goto crc32;
        case 0x038:
            b = modrm;
            modrm = ldub_code(s->pc++);
            rm = modrm & 7;
            reg = ((modrm >> 3) & 7) | rex_r;
            mod = (modrm >> 6) & 3;
            if (b1 >= 2) {
                goto illegal_op;
            }

            sse_op2 = sse_op_table6[b].op[b1];
            if (!sse_op2)
                goto illegal_op;
            if (!(s->cpuid_ext_features & sse_op_table6[b].ext_mask))
                goto illegal_op;

            if (b1) {
                op1_offset = __builtin_offsetof (CPUX86State, xmm_regs[reg]);
                if (mod == 3) {
                    op2_offset = __builtin_offsetof (CPUX86State, xmm_regs[rm | ((s)->rex_b)]);
                } else {
                    op2_offset = __builtin_offsetof (CPUX86State, xmm_t0);
                    gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                    switch (b) {
                    case 0x20: case 0x30:
                    case 0x23: case 0x33:
                    case 0x25: case 0x35:
                        gen_ldq_env_A0(s->mem_index, op2_offset +
                                        __builtin_offsetof (XMMReg, _q[0]));
                        break;
                    case 0x21: case 0x31:
                    case 0x24: case 0x34:
                        tcg_gen_qemu_ld32u(cpu_tmp0, cpu_A0,
                                          (s->mem_index >> 2) - 1);
                        tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_tmp0);
                        tcg_gen_st_i32(cpu_tmp2_i32, cpu_env, op2_offset +
                                        __builtin_offsetof (XMMReg, _l[0]));
                        break;
                    case 0x22: case 0x32:
                        tcg_gen_qemu_ld16u(cpu_tmp0, cpu_A0,
                                          (s->mem_index >> 2) - 1);
                        tcg_gen_st16_i64(cpu_tmp0, cpu_env, op2_offset +
                                        __builtin_offsetof (XMMReg, _w[0]));
                        break;
                    case 0x2a:
                        gen_ldo_env_A0(s->mem_index, op1_offset);
                        return;
                    default:
                        gen_ldo_env_A0(s->mem_index, op2_offset);
                    }
                }
            } else {
                op1_offset = __builtin_offsetof (CPUX86State, fpregs[reg].mmx);
                if (mod == 3) {
                    op2_offset = __builtin_offsetof (CPUX86State, fpregs[rm].mmx);
                } else {
                    op2_offset = __builtin_offsetof (CPUX86State, mmx_t0);
                    gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                    gen_ldq_env_A0(s->mem_index, op2_offset);
                }
            }
            if (sse_op2 == ((void *)1))
                goto illegal_op;

            tcg_gen_addi_i32(cpu_ptr0, cpu_env, op1_offset);
            tcg_gen_addi_i32(cpu_ptr1, cpu_env, op2_offset);
            ((void (*)(TCGv_i32, TCGv_i32))sse_op2)(cpu_ptr0, cpu_ptr1);

            if (b == 0x17)
                s->cc_op = CC_OP_EFLAGS;
            break;
        case 0x338:
        crc32:
            b = modrm;
            modrm = ldub_code(s->pc++);
            reg = ((modrm >> 3) & 7) | rex_r;

            if (b != 0xf0 && b != 0xf1)
                goto illegal_op;
            if (!(s->cpuid_ext_features & (1 << 20)))
                goto illegal_op;

            if (b == 0xf0)
                ot = OT_BYTE;
            else if (b == 0xf1 && s->dflag != 2)
                if (s->prefix & 0x08)
                    ot = OT_WORD;
                else
                    ot = OT_LONG;
            else
                ot = OT_QUAD;

            gen_op_mov_TN_reg(OT_LONG, 0, reg);
            tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
            gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
            gen_helper_crc32(cpu_T[0], cpu_tmp2_i32,
                             cpu_T[0], tcg_const_i32(8 << ot));

            ot = (s->dflag == 2) ? OT_QUAD : OT_LONG;
            gen_op_mov_reg_T0(ot, reg);
            break;
        case 0x03a:
        case 0x13a:
            b = modrm;
            modrm = ldub_code(s->pc++);
            rm = modrm & 7;
            reg = ((modrm >> 3) & 7) | rex_r;
            mod = (modrm >> 6) & 3;
            if (b1 >= 2) {
                goto illegal_op;
            }

            sse_op2 = sse_op_table7[b].op[b1];
            if (!sse_op2)
                goto illegal_op;
            if (!(s->cpuid_ext_features & sse_op_table7[b].ext_mask))
                goto illegal_op;

            if (sse_op2 == ((void *)1)) {
                ot = (s->dflag == 2) ? OT_QUAD : OT_LONG;
                rm = (modrm & 7) | ((s)->rex_b);
                if (mod != 3)
                    gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                reg = ((modrm >> 3) & 7) | rex_r;
                val = ldub_code(s->pc++);
                switch (b) {
                case 0x14:
                    tcg_gen_ld8u_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, xmm_regs[reg]._b[val & 15])
                                                                          );
                    if (mod == 3)
                        gen_op_mov_reg_T0(ot, rm);
                    else
                        tcg_gen_qemu_st8(cpu_T[0], cpu_A0,
                                        (s->mem_index >> 2) - 1);
                    break;
                case 0x15:
                    tcg_gen_ld16u_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, xmm_regs[reg]._w[val & 7])
                                                                         );
                    if (mod == 3)
                        gen_op_mov_reg_T0(ot, rm);
                    else
                        tcg_gen_qemu_st16(cpu_T[0], cpu_A0,
                                        (s->mem_index >> 2) - 1);
                    break;
                case 0x16:
                    if (ot == OT_LONG) {
                        tcg_gen_ld_i32(cpu_tmp2_i32, cpu_env,
                                        __builtin_offsetof (CPUX86State, xmm_regs[reg]._l[val & 3])
                                                                             );
                        tcg_gen_extu_i32_i64(cpu_T[0], cpu_tmp2_i32);
                        if (mod == 3)
                            gen_op_mov_reg_v(ot, rm, cpu_T[0]);
                        else
                            tcg_gen_qemu_st32(cpu_T[0], cpu_A0,
                                            (s->mem_index >> 2) - 1);
                    } else {

                        tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env,
                                        __builtin_offsetof (CPUX86State, xmm_regs[reg]._q[val & 1])
                                                                             );
                        if (mod == 3)
                            gen_op_mov_reg_v(ot, rm, cpu_tmp1_i64);
                        else
                            tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0,
                                            (s->mem_index >> 2) - 1);



                    }
                    break;
                case 0x17:
                    tcg_gen_ld32u_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, xmm_regs[reg]._l[val & 3])
                                                                         );
                    if (mod == 3)
                        gen_op_mov_reg_T0(ot, rm);
                    else
                        tcg_gen_qemu_st32(cpu_T[0], cpu_A0,
                                        (s->mem_index >> 2) - 1);
                    break;
                case 0x20:
                    if (mod == 3)
                        gen_op_mov_TN_reg(OT_LONG, 0, rm);
                    else
                        tcg_gen_qemu_ld8u(cpu_tmp0, cpu_A0,
                                        (s->mem_index >> 2) - 1);
                    tcg_gen_st8_i64(cpu_tmp0, cpu_env, __builtin_offsetof (CPUX86State, xmm_regs[reg]._b[val & 15])
                                                                          );
                    break;
                case 0x21:
                    if (mod == 3) {
                        tcg_gen_ld_i32(cpu_tmp2_i32, cpu_env,
                                        __builtin_offsetof (CPUX86State, xmm_regs[rm] ._l[(val >> 6) & 3])
                                                                       );
                    } else {
                        tcg_gen_qemu_ld32u(cpu_tmp0, cpu_A0,
                                        (s->mem_index >> 2) - 1);
                        tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_tmp0);
                    }
                    tcg_gen_st_i32(cpu_tmp2_i32, cpu_env,
                                    __builtin_offsetof (CPUX86State, xmm_regs[reg] ._l[(val >> 4) & 3])
                                                                   );
                    if ((val >> 0) & 1)
                        tcg_gen_st_i32(tcg_const_i32(0 ),
                                        cpu_env, __builtin_offsetof (CPUX86State, xmm_regs[reg]._l[0])
                                                                       );
                    if ((val >> 1) & 1)
                        tcg_gen_st_i32(tcg_const_i32(0 ),
                                        cpu_env, __builtin_offsetof (CPUX86State, xmm_regs[reg]._l[1])
                                                                       );
                    if ((val >> 2) & 1)
                        tcg_gen_st_i32(tcg_const_i32(0 ),
                                        cpu_env, __builtin_offsetof (CPUX86State, xmm_regs[reg]._l[2])
                                                                       );
                    if ((val >> 3) & 1)
                        tcg_gen_st_i32(tcg_const_i32(0 ),
                                        cpu_env, __builtin_offsetof (CPUX86State, xmm_regs[reg]._l[3])
                                                                       );
                    break;
                case 0x22:
                    if (ot == OT_LONG) {
                        if (mod == 3)
                            gen_op_mov_v_reg(ot, cpu_tmp0, rm);
                        else
                            tcg_gen_qemu_ld32u(cpu_tmp0, cpu_A0,
                                            (s->mem_index >> 2) - 1);
                        tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_tmp0);
                        tcg_gen_st_i32(cpu_tmp2_i32, cpu_env,
                                        __builtin_offsetof (CPUX86State, xmm_regs[reg]._l[val & 3])
                                                                             );
                    } else {

                        if (mod == 3)
                            gen_op_mov_v_reg(ot, cpu_tmp1_i64, rm);
                        else
                            tcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0,
                                            (s->mem_index >> 2) - 1);
                        tcg_gen_st_i64(cpu_tmp1_i64, cpu_env,
                                        __builtin_offsetof (CPUX86State, xmm_regs[reg]._q[val & 1])
                                                                             );



                    }
                    break;
                }
                return;
            }

            if (b1) {
                op1_offset = __builtin_offsetof (CPUX86State, xmm_regs[reg]);
                if (mod == 3) {
                    op2_offset = __builtin_offsetof (CPUX86State, xmm_regs[rm | ((s)->rex_b)]);
                } else {
                    op2_offset = __builtin_offsetof (CPUX86State, xmm_t0);
                    gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                    gen_ldo_env_A0(s->mem_index, op2_offset);
                }
            } else {
                op1_offset = __builtin_offsetof (CPUX86State, fpregs[reg].mmx);
                if (mod == 3) {
                    op2_offset = __builtin_offsetof (CPUX86State, fpregs[rm].mmx);
                } else {
                    op2_offset = __builtin_offsetof (CPUX86State, mmx_t0);
                    gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                    gen_ldq_env_A0(s->mem_index, op2_offset);
                }
            }
            val = ldub_code(s->pc++);

            if ((b & 0xfc) == 0x60) {
                s->cc_op = CC_OP_EFLAGS;

                if (s->dflag == 2)

                    val |= 1 << 8;
            }

            tcg_gen_addi_i32(cpu_ptr0, cpu_env, op1_offset);
            tcg_gen_addi_i32(cpu_ptr1, cpu_env, op2_offset);
            ((void (*)(TCGv_i32, TCGv_i32, TCGv_i32))sse_op2)(cpu_ptr0, cpu_ptr1, tcg_const_i32(val));
            break;
        default:
            goto illegal_op;
        }
    } else {

        switch(b) {
        case 0x70:
        case 0xc6:
        case 0xc2:
            s->rip_offset = 1;
            break;
        default:
            break;
        }
        if (is_xmm) {
            op1_offset = __builtin_offsetof (CPUX86State, xmm_regs[reg]);
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                op2_offset = __builtin_offsetof (CPUX86State, xmm_t0);
                if (b1 >= 2 && ((b >= 0x50 && b <= 0x5f && b != 0x5b) ||
                                b == 0xc2)) {

                    if (b1 == 2) {

                        gen_op_ld_T0_A0(OT_LONG + s->mem_index);
                        tcg_gen_st32_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, xmm_t0._l[0]));
                    } else {

                        gen_ldq_env_A0(s->mem_index, __builtin_offsetof (CPUX86State, xmm_t0._d[0]));
                    }
                } else {
                    gen_ldo_env_A0(s->mem_index, op2_offset);
                }
            } else {
                rm = (modrm & 7) | ((s)->rex_b);
                op2_offset = __builtin_offsetof (CPUX86State, xmm_regs[rm]);
            }
        } else {
            op1_offset = __builtin_offsetof (CPUX86State, fpregs[reg].mmx);
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                op2_offset = __builtin_offsetof (CPUX86State, mmx_t0);
                gen_ldq_env_A0(s->mem_index, op2_offset);
            } else {
                rm = (modrm & 7);
                op2_offset = __builtin_offsetof (CPUX86State, fpregs[rm].mmx);
            }
        }
        switch(b) {
        case 0x0f:
            if (!(s->cpuid_ext2_features & (1 << 31)))
                goto illegal_op;
            val = ldub_code(s->pc++);
            sse_op2 = sse_op_table5[val];
            if (!sse_op2)
                goto illegal_op;
            tcg_gen_addi_i32(cpu_ptr0, cpu_env, op1_offset);
            tcg_gen_addi_i32(cpu_ptr1, cpu_env, op2_offset);
            ((void (*)(TCGv_i32, TCGv_i32))sse_op2)(cpu_ptr0, cpu_ptr1);
            break;
        case 0x70:
        case 0xc6:
            val = ldub_code(s->pc++);
            tcg_gen_addi_i32(cpu_ptr0, cpu_env, op1_offset);
            tcg_gen_addi_i32(cpu_ptr1, cpu_env, op2_offset);
            ((void (*)(TCGv_i32, TCGv_i32, TCGv_i32))sse_op2)(cpu_ptr0, cpu_ptr1, tcg_const_i32(val));
            break;
        case 0xc2:

            val = ldub_code(s->pc++);
            if (val >= 8)
                goto illegal_op;
            sse_op2 = sse_op_table4[val][b1];
            tcg_gen_addi_i32(cpu_ptr0, cpu_env, op1_offset);
            tcg_gen_addi_i32(cpu_ptr1, cpu_env, op2_offset);
            ((void (*)(TCGv_i32, TCGv_i32))sse_op2)(cpu_ptr0, cpu_ptr1);
            break;
        case 0xf7:

            if (mod != 3)
                goto illegal_op;

            if (s->aflag == 2) {
                gen_op_movq_A0_reg(7);
            } else

            {
                gen_op_movl_A0_reg(7);
                if (s->aflag == 0)
                    gen_op_andl_A0_ffff();
            }
            gen_add_A0_ds_seg(s);

            tcg_gen_addi_i32(cpu_ptr0, cpu_env, op1_offset);
            tcg_gen_addi_i32(cpu_ptr1, cpu_env, op2_offset);
            ((void (*)(TCGv_i32, TCGv_i32, TCGv_i64))sse_op2)(cpu_ptr0, cpu_ptr1, cpu_A0);
            break;
        default:
            tcg_gen_addi_i32(cpu_ptr0, cpu_env, op1_offset);
            tcg_gen_addi_i32(cpu_ptr1, cpu_env, op2_offset);
            ((void (*)(TCGv_i32, TCGv_i32))sse_op2)(cpu_ptr0, cpu_ptr1);
            break;
        }
        if (b == 0x2e || b == 0x2f) {
            s->cc_op = CC_OP_EFLAGS;
        }
    }
}



static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
{
    int b, prefixes, aflag, dflag;
    int shift, ot;
    int modrm, reg, rm, mod, reg_addr, op, opreg, offset_addr, val;
    target_ulong next_eip, tval;
    int rex_w, rex_r;

    if (__builtin_expect(!!(((loglevel & ((1 << 2))) != 0)), 0))
        tcg_gen_debug_insn_start(pc_start);
    s->pc = pc_start;
    prefixes = 0;
    aflag = s->code32;
    dflag = s->code32;
    s->override = -1;
    rex_w = -1;
    rex_r = 0;

    s->rex_x = 0;
    s->rex_b = 0;
    x86_64_hregs = 0;

    s->rip_offset = 0;
 next_byte:
    b = ldub_code(s->pc);
    s->pc++;


    if (((s)->code64)) {
        switch (b) {
        case 0xf3:
            prefixes |= 0x01;
            goto next_byte;
        case 0xf2:
            prefixes |= 0x02;
            goto next_byte;
        case 0xf0:
            prefixes |= 0x04;
            goto next_byte;
        case 0x2e:
            s->override = 1;
            goto next_byte;
        case 0x36:
            s->override = 2;
            goto next_byte;
        case 0x3e:
            s->override = 3;
            goto next_byte;
        case 0x26:
            s->override = 0;
            goto next_byte;
        case 0x64:
            s->override = 4;
            goto next_byte;
        case 0x65:
            s->override = 5;
            goto next_byte;
        case 0x66:
            prefixes |= 0x08;
            goto next_byte;
        case 0x67:
            prefixes |= 0x10;
            goto next_byte;
        case 0x40 ... 0x4f:

            rex_w = (b >> 3) & 1;
            rex_r = (b & 0x4) << 1;
            s->rex_x = (b & 0x2) << 2;
            ((s)->rex_b) = (b & 0x1) << 3;
            x86_64_hregs = 1;
            goto next_byte;
        }
        if (rex_w == 1) {

            dflag = 2;
        } else {
            if (prefixes & 0x08)
                dflag ^= 1;
        }
        if (!(prefixes & 0x10))
            aflag = 2;
    } else

    {
        switch (b) {
        case 0xf3:
            prefixes |= 0x01;
            goto next_byte;
        case 0xf2:
            prefixes |= 0x02;
            goto next_byte;
        case 0xf0:
            prefixes |= 0x04;
            goto next_byte;
        case 0x2e:
            s->override = 1;
            goto next_byte;
        case 0x36:
            s->override = 2;
            goto next_byte;
        case 0x3e:
            s->override = 3;
            goto next_byte;
        case 0x26:
            s->override = 0;
            goto next_byte;
        case 0x64:
            s->override = 4;
            goto next_byte;
        case 0x65:
            s->override = 5;
            goto next_byte;
        case 0x66:
            prefixes |= 0x08;
            goto next_byte;
        case 0x67:
            prefixes |= 0x10;
            goto next_byte;
        }
        if (prefixes & 0x08)
            dflag ^= 1;
        if (prefixes & 0x10)
            aflag ^= 1;
    }

    s->prefix = prefixes;
    s->aflag = aflag;
    s->dflag = dflag;


    if (prefixes & 0x04)
        gen_helper_lock();


 reswitch:
    switch(b) {
    case 0x0f:


        b = ldub_code(s->pc++) | 0x100;
        goto reswitch;



    case 0x00 ... 0x05:
    case 0x08 ... 0x0d:
    case 0x10 ... 0x15:
    case 0x18 ... 0x1d:
    case 0x20 ... 0x25:
    case 0x28 ... 0x2d:
    case 0x30 ... 0x35:
    case 0x38 ... 0x3d:
        {
            int op, f, val;
            op = (b >> 3) & 7;
            f = (b >> 1) & 3;

            if ((b & 1) == 0)
                ot = OT_BYTE;
            else
                ot = dflag + OT_WORD;

            switch(f) {
            case 0:
                modrm = ldub_code(s->pc++);
                reg = ((modrm >> 3) & 7) | rex_r;
                mod = (modrm >> 6) & 3;
                rm = (modrm & 7) | ((s)->rex_b);
                if (mod != 3) {
                    gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                    opreg = OR_TMP0;
                } else if (op == OP_XORL && rm == reg) {
                xor_zero:

                    gen_op_movl_T0_0();
                    s->cc_op = CC_OP_LOGICB + ot;
                    gen_op_mov_reg_T0(ot, reg);
                    gen_op_update1_cc();
                    break;
                } else {
                    opreg = rm;
                }
                gen_op_mov_TN_reg(ot, 1, reg);
                gen_op(s, op, ot, opreg);
                break;
            case 1:
                modrm = ldub_code(s->pc++);
                mod = (modrm >> 6) & 3;
                reg = ((modrm >> 3) & 7) | rex_r;
                rm = (modrm & 7) | ((s)->rex_b);
                if (mod != 3) {
                    gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                    gen_op_ld_T1_A0(ot + s->mem_index);
                } else if (op == OP_XORL && rm == reg) {
                    goto xor_zero;
                } else {
                    gen_op_mov_TN_reg(ot, 1, rm);
                }
                gen_op(s, op, ot, reg);
                break;
            case 2:
                val = insn_get(s, ot);
                gen_op_movl_T1_im(val);
                gen_op(s, op, ot, OR_EAX);
                break;
            }
        }
        break;

    case 0x82:
        if (((s)->code64))
            goto illegal_op;
    case 0x80:
    case 0x81:
    case 0x83:
        {
            int val;

            if ((b & 1) == 0)
                ot = OT_BYTE;
            else
                ot = dflag + OT_WORD;

            modrm = ldub_code(s->pc++);
            mod = (modrm >> 6) & 3;
            rm = (modrm & 7) | ((s)->rex_b);
            op = (modrm >> 3) & 7;

            if (mod != 3) {
                if (b == 0x83)
                    s->rip_offset = 1;
                else
                    s->rip_offset = insn_const_size(ot);
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                opreg = OR_TMP0;
            } else {
                opreg = rm;
            }

            switch(b) {
            default:
            case 0x80:
            case 0x81:
            case 0x82:
                val = insn_get(s, ot);
                break;
            case 0x83:
                val = (int8_t)insn_get(s, OT_BYTE);
                break;
            }
            gen_op_movl_T1_im(val);
            gen_op(s, op, ot, opreg);
        }
        break;



    case 0x40 ... 0x47:
        ot = dflag ? OT_LONG : OT_WORD;
        gen_inc(s, ot, OR_EAX + (b & 7), 1);
        break;
    case 0x48 ... 0x4f:
        ot = dflag ? OT_LONG : OT_WORD;
        gen_inc(s, ot, OR_EAX + (b & 7), -1);
        break;
    case 0xf6:
    case 0xf7:
        if ((b & 1) == 0)
            ot = OT_BYTE;
        else
            ot = dflag + OT_WORD;

        modrm = ldub_code(s->pc++);
        mod = (modrm >> 6) & 3;
        rm = (modrm & 7) | ((s)->rex_b);
        op = (modrm >> 3) & 7;
        if (mod != 3) {
            if (op == 0)
                s->rip_offset = insn_const_size(ot);
            gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
            gen_op_ld_T0_A0(ot + s->mem_index);
        } else {
            gen_op_mov_TN_reg(ot, 0, rm);
        }

        switch(op) {
        case 0:
            val = insn_get(s, ot);
            gen_op_movl_T1_im(val);
            gen_op_testl_T0_T1_cc();
            s->cc_op = CC_OP_LOGICB + ot;
            break;
        case 2:
            tcg_gen_not_i64(cpu_T[0], cpu_T[0]);
            if (mod != 3) {
                gen_op_st_T0_A0(ot + s->mem_index);
            } else {
                gen_op_mov_reg_T0(ot, rm);
            }
            break;
        case 3:
            tcg_gen_neg_i64(cpu_T[0], cpu_T[0]);
            if (mod != 3) {
                gen_op_st_T0_A0(ot + s->mem_index);
            } else {
                gen_op_mov_reg_T0(ot, rm);
            }
            gen_op_update_neg_cc();
            s->cc_op = CC_OP_SUBB + ot;
            break;
        case 4:
            switch(ot) {
            case OT_BYTE:
                gen_op_mov_TN_reg(OT_BYTE, 1, 0);
                tcg_gen_ext8u_i64(cpu_T[0], cpu_T[0]);
                tcg_gen_ext8u_i64(cpu_T[1], cpu_T[1]);

                tcg_gen_mul_i64(cpu_T[0], cpu_T[0], cpu_T[1]);
                gen_op_mov_reg_T0(OT_WORD, 0);
                tcg_gen_mov_i64(cpu_cc_dst, cpu_T[0]);
                tcg_gen_andi_i64(cpu_cc_src, cpu_T[0], 0xff00);
                s->cc_op = CC_OP_MULB;
                break;
            case OT_WORD:
                gen_op_mov_TN_reg(OT_WORD, 1, 0);
                tcg_gen_ext16u_i64(cpu_T[0], cpu_T[0]);
                tcg_gen_ext16u_i64(cpu_T[1], cpu_T[1]);

                tcg_gen_mul_i64(cpu_T[0], cpu_T[0], cpu_T[1]);
                gen_op_mov_reg_T0(OT_WORD, 0);
                tcg_gen_mov_i64(cpu_cc_dst, cpu_T[0]);
                tcg_gen_shri_i64(cpu_T[0], cpu_T[0], 16);
                gen_op_mov_reg_T0(OT_WORD, 2);
                tcg_gen_mov_i64(cpu_cc_src, cpu_T[0]);
                s->cc_op = CC_OP_MULW;
                break;
            default:
            case OT_LONG:

                gen_op_mov_TN_reg(OT_LONG, 1, 0);
                tcg_gen_ext32u_i64(cpu_T[0], cpu_T[0]);
                tcg_gen_ext32u_i64(cpu_T[1], cpu_T[1]);
                tcg_gen_mul_i64(cpu_T[0], cpu_T[0], cpu_T[1]);
                gen_op_mov_reg_T0(OT_LONG, 0);
                tcg_gen_mov_i64(cpu_cc_dst, cpu_T[0]);
                tcg_gen_shri_i64(cpu_T[0], cpu_T[0], 32);
                gen_op_mov_reg_T0(OT_LONG, 2);
                tcg_gen_mov_i64(cpu_cc_src, cpu_T[0]);
# 4429 "../../target-i386/translate.c"
                s->cc_op = CC_OP_MULL;
                break;

            case OT_QUAD:
                gen_helper_mulq_EAX_T0(cpu_T[0]);
                s->cc_op = CC_OP_MULQ;
                break;

            }
            break;
        case 5:
            switch(ot) {
            case OT_BYTE:
                gen_op_mov_TN_reg(OT_BYTE, 1, 0);
                tcg_gen_ext8s_i64(cpu_T[0], cpu_T[0]);
                tcg_gen_ext8s_i64(cpu_T[1], cpu_T[1]);

                tcg_gen_mul_i64(cpu_T[0], cpu_T[0], cpu_T[1]);
                gen_op_mov_reg_T0(OT_WORD, 0);
                tcg_gen_mov_i64(cpu_cc_dst, cpu_T[0]);
                tcg_gen_ext8s_i64(cpu_tmp0, cpu_T[0]);
                tcg_gen_sub_i64(cpu_cc_src, cpu_T[0], cpu_tmp0);
                s->cc_op = CC_OP_MULB;
                break;
            case OT_WORD:
                gen_op_mov_TN_reg(OT_WORD, 1, 0);
                tcg_gen_ext16s_i64(cpu_T[0], cpu_T[0]);
                tcg_gen_ext16s_i64(cpu_T[1], cpu_T[1]);

                tcg_gen_mul_i64(cpu_T[0], cpu_T[0], cpu_T[1]);
                gen_op_mov_reg_T0(OT_WORD, 0);
                tcg_gen_mov_i64(cpu_cc_dst, cpu_T[0]);
                tcg_gen_ext16s_i64(cpu_tmp0, cpu_T[0]);
                tcg_gen_sub_i64(cpu_cc_src, cpu_T[0], cpu_tmp0);
                tcg_gen_shri_i64(cpu_T[0], cpu_T[0], 16);
                gen_op_mov_reg_T0(OT_WORD, 2);
                s->cc_op = CC_OP_MULW;
                break;
            default:
            case OT_LONG:

                gen_op_mov_TN_reg(OT_LONG, 1, 0);
                tcg_gen_ext32s_i64(cpu_T[0], cpu_T[0]);
                tcg_gen_ext32s_i64(cpu_T[1], cpu_T[1]);
                tcg_gen_mul_i64(cpu_T[0], cpu_T[0], cpu_T[1]);
                gen_op_mov_reg_T0(OT_LONG, 0);
                tcg_gen_mov_i64(cpu_cc_dst, cpu_T[0]);
                tcg_gen_ext32s_i64(cpu_tmp0, cpu_T[0]);
                tcg_gen_sub_i64(cpu_cc_src, cpu_T[0], cpu_tmp0);
                tcg_gen_shri_i64(cpu_T[0], cpu_T[0], 32);
                gen_op_mov_reg_T0(OT_LONG, 2);
# 4499 "../../target-i386/translate.c"
                s->cc_op = CC_OP_MULL;
                break;

            case OT_QUAD:
                gen_helper_imulq_EAX_T0(cpu_T[0]);
                s->cc_op = CC_OP_MULQ;
                break;

            }
            break;
        case 6:
            switch(ot) {
            case OT_BYTE:
                gen_jmp_im(pc_start - s->cs_base);
                gen_helper_divb_AL(cpu_T[0]);
                break;
            case OT_WORD:
                gen_jmp_im(pc_start - s->cs_base);
                gen_helper_divw_AX(cpu_T[0]);
                break;
            default:
            case OT_LONG:
                gen_jmp_im(pc_start - s->cs_base);
                gen_helper_divl_EAX(cpu_T[0]);
                break;

            case OT_QUAD:
                gen_jmp_im(pc_start - s->cs_base);
                gen_helper_divq_EAX(cpu_T[0]);
                break;

            }
            break;
        case 7:
            switch(ot) {
            case OT_BYTE:
                gen_jmp_im(pc_start - s->cs_base);
                gen_helper_idivb_AL(cpu_T[0]);
                break;
            case OT_WORD:
                gen_jmp_im(pc_start - s->cs_base);
                gen_helper_idivw_AX(cpu_T[0]);
                break;
            default:
            case OT_LONG:
                gen_jmp_im(pc_start - s->cs_base);
                gen_helper_idivl_EAX(cpu_T[0]);
                break;

            case OT_QUAD:
                gen_jmp_im(pc_start - s->cs_base);
                gen_helper_idivq_EAX(cpu_T[0]);
                break;

            }
            break;
        default:
            goto illegal_op;
        }
        break;

    case 0xfe:
    case 0xff:
        if ((b & 1) == 0)
            ot = OT_BYTE;
        else
            ot = dflag + OT_WORD;

        modrm = ldub_code(s->pc++);
        mod = (modrm >> 6) & 3;
        rm = (modrm & 7) | ((s)->rex_b);
        op = (modrm >> 3) & 7;
        if (op >= 2 && b == 0xfe) {
            goto illegal_op;
        }
        if (((s)->code64)) {
            if (op == 2 || op == 4) {

                ot = OT_QUAD;
            } else if (op == 3 || op == 5) {
                ot = dflag ? OT_LONG + (rex_w == 1) : OT_WORD;
            } else if (op == 6) {

                ot = dflag ? OT_QUAD : OT_WORD;
            }
        }
        if (mod != 3) {
            gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
            if (op >= 2 && op != 3 && op != 5)
                gen_op_ld_T0_A0(ot + s->mem_index);
        } else {
            gen_op_mov_TN_reg(ot, 0, rm);
        }

        switch(op) {
        case 0:
            if (mod != 3)
                opreg = OR_TMP0;
            else
                opreg = rm;
            gen_inc(s, ot, opreg, 1);
            break;
        case 1:
            if (mod != 3)
                opreg = OR_TMP0;
            else
                opreg = rm;
            gen_inc(s, ot, opreg, -1);
            break;
        case 2:

            if (s->dflag == 0)
                gen_op_andl_T0_ffff();
            next_eip = s->pc - s->cs_base;
            gen_movtl_T1_im(next_eip);
            gen_push_T1(s);
            gen_op_jmp_T0();
            gen_eob(s);
            break;
        case 3:
            gen_op_ld_T1_A0(ot + s->mem_index);
            gen_add_A0_im(s, 1 << (ot - OT_WORD + 1));
            gen_op_ldu_T0_A0(OT_WORD + s->mem_index);
        do_lcall:
            if (s->pe && !s->vm86) {
                if (s->cc_op != CC_OP_DYNAMIC)
                    gen_op_set_cc_op(s->cc_op);
                gen_jmp_im(pc_start - s->cs_base);
                tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
                gen_helper_lcall_protected(cpu_tmp2_i32, cpu_T[1],
                                           tcg_const_i32(dflag),
                                           tcg_const_i32(s->pc - pc_start));
            } else {
                tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
                gen_helper_lcall_real(cpu_tmp2_i32, cpu_T[1],
                                      tcg_const_i32(dflag),
                                      tcg_const_i32(s->pc - s->cs_base));
            }
            gen_eob(s);
            break;
        case 4:
            if (s->dflag == 0)
                gen_op_andl_T0_ffff();
            gen_op_jmp_T0();
            gen_eob(s);
            break;
        case 5:
            gen_op_ld_T1_A0(ot + s->mem_index);
            gen_add_A0_im(s, 1 << (ot - OT_WORD + 1));
            gen_op_ldu_T0_A0(OT_WORD + s->mem_index);
        do_ljmp:
            if (s->pe && !s->vm86) {
                if (s->cc_op != CC_OP_DYNAMIC)
                    gen_op_set_cc_op(s->cc_op);
                gen_jmp_im(pc_start - s->cs_base);
                tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
                gen_helper_ljmp_protected(cpu_tmp2_i32, cpu_T[1],
                                          tcg_const_i32(s->pc - pc_start));
            } else {
                gen_op_movl_seg_T0_vm(1);
                gen_op_movl_T0_T1();
                gen_op_jmp_T0();
            }
            gen_eob(s);
            break;
        case 6:
            gen_push_T0(s);
            break;
        default:
            goto illegal_op;
        }
        break;

    case 0x84:
    case 0x85:
        if ((b & 1) == 0)
            ot = OT_BYTE;
        else
            ot = dflag + OT_WORD;

        modrm = ldub_code(s->pc++);
        reg = ((modrm >> 3) & 7) | rex_r;

        gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
        gen_op_mov_TN_reg(ot, 1, reg);
        gen_op_testl_T0_T1_cc();
        s->cc_op = CC_OP_LOGICB + ot;
        break;

    case 0xa8:
    case 0xa9:
        if ((b & 1) == 0)
            ot = OT_BYTE;
        else
            ot = dflag + OT_WORD;
        val = insn_get(s, ot);

        gen_op_mov_TN_reg(ot, 0, OR_EAX);
        gen_op_movl_T1_im(val);
        gen_op_testl_T0_T1_cc();
        s->cc_op = CC_OP_LOGICB + ot;
        break;

    case 0x98:

        if (dflag == 2) {
            gen_op_mov_TN_reg(OT_LONG, 0, 0);
            tcg_gen_ext32s_i64(cpu_T[0], cpu_T[0]);
            gen_op_mov_reg_T0(OT_QUAD, 0);
        } else

        if (dflag == 1) {
            gen_op_mov_TN_reg(OT_WORD, 0, 0);
            tcg_gen_ext16s_i64(cpu_T[0], cpu_T[0]);
            gen_op_mov_reg_T0(OT_LONG, 0);
        } else {
            gen_op_mov_TN_reg(OT_BYTE, 0, 0);
            tcg_gen_ext8s_i64(cpu_T[0], cpu_T[0]);
            gen_op_mov_reg_T0(OT_WORD, 0);
        }
        break;
    case 0x99:

        if (dflag == 2) {
            gen_op_mov_TN_reg(OT_QUAD, 0, 0);
            tcg_gen_sari_i64(cpu_T[0], cpu_T[0], 63);
            gen_op_mov_reg_T0(OT_QUAD, 2);
        } else

        if (dflag == 1) {
            gen_op_mov_TN_reg(OT_LONG, 0, 0);
            tcg_gen_ext32s_i64(cpu_T[0], cpu_T[0]);
            tcg_gen_sari_i64(cpu_T[0], cpu_T[0], 31);
            gen_op_mov_reg_T0(OT_LONG, 2);
        } else {
            gen_op_mov_TN_reg(OT_WORD, 0, 0);
            tcg_gen_ext16s_i64(cpu_T[0], cpu_T[0]);
            tcg_gen_sari_i64(cpu_T[0], cpu_T[0], 15);
            gen_op_mov_reg_T0(OT_WORD, 2);
        }
        break;
    case 0x1af:
    case 0x69:
    case 0x6b:
        ot = dflag + OT_WORD;
        modrm = ldub_code(s->pc++);
        reg = ((modrm >> 3) & 7) | rex_r;
        if (b == 0x69)
            s->rip_offset = insn_const_size(ot);
        else if (b == 0x6b)
            s->rip_offset = 1;
        gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
        if (b == 0x69) {
            val = insn_get(s, ot);
            gen_op_movl_T1_im(val);
        } else if (b == 0x6b) {
            val = (int8_t)insn_get(s, OT_BYTE);
            gen_op_movl_T1_im(val);
        } else {
            gen_op_mov_TN_reg(ot, 1, reg);
        }


        if (ot == OT_QUAD) {
            gen_helper_imulq_T0_T1(cpu_T[0], cpu_T[0], cpu_T[1]);
        } else

        if (ot == OT_LONG) {

                tcg_gen_ext32s_i64(cpu_T[0], cpu_T[0]);
                tcg_gen_ext32s_i64(cpu_T[1], cpu_T[1]);
                tcg_gen_mul_i64(cpu_T[0], cpu_T[0], cpu_T[1]);
                tcg_gen_mov_i64(cpu_cc_dst, cpu_T[0]);
                tcg_gen_ext32s_i64(cpu_tmp0, cpu_T[0]);
                tcg_gen_sub_i64(cpu_cc_src, cpu_T[0], cpu_tmp0);
# 4790 "../../target-i386/translate.c"
        } else {
            tcg_gen_ext16s_i64(cpu_T[0], cpu_T[0]);
            tcg_gen_ext16s_i64(cpu_T[1], cpu_T[1]);

            tcg_gen_mul_i64(cpu_T[0], cpu_T[0], cpu_T[1]);
            tcg_gen_mov_i64(cpu_cc_dst, cpu_T[0]);
            tcg_gen_ext16s_i64(cpu_tmp0, cpu_T[0]);
            tcg_gen_sub_i64(cpu_cc_src, cpu_T[0], cpu_tmp0);
        }
        gen_op_mov_reg_T0(ot, reg);
        s->cc_op = CC_OP_MULB + ot;
        break;
    case 0x1c0:
    case 0x1c1:
        if ((b & 1) == 0)
            ot = OT_BYTE;
        else
            ot = dflag + OT_WORD;
        modrm = ldub_code(s->pc++);
        reg = ((modrm >> 3) & 7) | rex_r;
        mod = (modrm >> 6) & 3;
        if (mod == 3) {
            rm = (modrm & 7) | ((s)->rex_b);
            gen_op_mov_TN_reg(ot, 0, reg);
            gen_op_mov_TN_reg(ot, 1, rm);
            gen_op_addl_T0_T1();
            gen_op_mov_reg_T1(ot, reg);
            gen_op_mov_reg_T0(ot, rm);
        } else {
            gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
            gen_op_mov_TN_reg(ot, 0, reg);
            gen_op_ld_T1_A0(ot + s->mem_index);
            gen_op_addl_T0_T1();
            gen_op_st_T0_A0(ot + s->mem_index);
            gen_op_mov_reg_T1(ot, reg);
        }
        gen_op_update2_cc();
        s->cc_op = CC_OP_ADDB + ot;
        break;
    case 0x1b0:
    case 0x1b1:
        {
            int label1, label2;
            TCGv_i64 t0, t1, t2, a0;

            if ((b & 1) == 0)
                ot = OT_BYTE;
            else
                ot = dflag + OT_WORD;
            modrm = ldub_code(s->pc++);
            reg = ((modrm >> 3) & 7) | rex_r;
            mod = (modrm >> 6) & 3;
            t0 = tcg_temp_local_new_i64();
            t1 = tcg_temp_local_new_i64();
            t2 = tcg_temp_local_new_i64();
            a0 = tcg_temp_local_new_i64();
            gen_op_mov_v_reg(ot, t1, reg);
            if (mod == 3) {
                rm = (modrm & 7) | ((s)->rex_b);
                gen_op_mov_v_reg(ot, t0, rm);
            } else {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                tcg_gen_mov_i64(a0, cpu_A0);
                gen_op_ld_v(ot + s->mem_index, t0, a0);
                rm = 0;
            }
            label1 = gen_new_label();
            tcg_gen_sub_i64(t2, cpu_regs[0], t0);
            gen_extu(ot, t2);
            tcg_gen_brcondi_i64(TCG_COND_EQ, t2, 0, label1);
            if (mod == 3) {
                label2 = gen_new_label();
                gen_op_mov_reg_v(ot, 0, t0);
                tcg_gen_br(label2);
                gen_set_label(label1);
                gen_op_mov_reg_v(ot, rm, t1);
                gen_set_label(label2);
            } else {
                tcg_gen_mov_i64(t1, t0);
                gen_op_mov_reg_v(ot, 0, t0);
                gen_set_label(label1);

                gen_op_st_v(ot + s->mem_index, t1, a0);
            }
            tcg_gen_mov_i64(cpu_cc_src, t0);
            tcg_gen_mov_i64(cpu_cc_dst, t2);
            s->cc_op = CC_OP_SUBB + ot;
            tcg_temp_free_i64(t0);
            tcg_temp_free_i64(t1);
            tcg_temp_free_i64(t2);
            tcg_temp_free_i64(a0);
        }
        break;
    case 0x1c7:
        modrm = ldub_code(s->pc++);
        mod = (modrm >> 6) & 3;
        if ((mod == 3) || ((modrm & 0x38) != 0x8))
            goto illegal_op;

        if (dflag == 2) {
            if (!(s->cpuid_ext_features & (1 << 13)))
                goto illegal_op;
            gen_jmp_im(pc_start - s->cs_base);
            if (s->cc_op != CC_OP_DYNAMIC)
                gen_op_set_cc_op(s->cc_op);
            gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
            gen_helper_cmpxchg16b(cpu_A0);
        } else

        {
            if (!(s->cpuid_features & (1 << 8)))
                goto illegal_op;
            gen_jmp_im(pc_start - s->cs_base);
            if (s->cc_op != CC_OP_DYNAMIC)
                gen_op_set_cc_op(s->cc_op);
            gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
            gen_helper_cmpxchg8b(cpu_A0);
        }
        s->cc_op = CC_OP_EFLAGS;
        break;



    case 0x50 ... 0x57:
        gen_op_mov_TN_reg(OT_LONG, 0, (b & 7) | ((s)->rex_b));
        gen_push_T0(s);
        break;
    case 0x58 ... 0x5f:
        if (((s)->code64)) {
            ot = dflag ? OT_QUAD : OT_WORD;
        } else {
            ot = dflag + OT_WORD;
        }
        gen_pop_T0(s);

        gen_pop_update(s);
        gen_op_mov_reg_T0(ot, (b & 7) | ((s)->rex_b));
        break;
    case 0x60:
        if (((s)->code64))
            goto illegal_op;
        gen_pusha(s);
        break;
    case 0x61:
        if (((s)->code64))
            goto illegal_op;
        gen_popa(s);
        break;
    case 0x68:
    case 0x6a:
        if (((s)->code64)) {
            ot = dflag ? OT_QUAD : OT_WORD;
        } else {
            ot = dflag + OT_WORD;
        }
        if (b == 0x68)
            val = insn_get(s, ot);
        else
            val = (int8_t)insn_get(s, OT_BYTE);
        gen_op_movl_T0_im(val);
        gen_push_T0(s);
        break;
    case 0x8f:
        if (((s)->code64)) {
            ot = dflag ? OT_QUAD : OT_WORD;
        } else {
            ot = dflag + OT_WORD;
        }
        modrm = ldub_code(s->pc++);
        mod = (modrm >> 6) & 3;
        gen_pop_T0(s);
        if (mod == 3) {

            gen_pop_update(s);
            rm = (modrm & 7) | ((s)->rex_b);
            gen_op_mov_reg_T0(ot, rm);
        } else {

            s->popl_esp_hack = 1 << ot;
            gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
            s->popl_esp_hack = 0;
            gen_pop_update(s);
        }
        break;
    case 0xc8:
        {
            int level;
            val = lduw_code(s->pc);
            s->pc += 2;
            level = ldub_code(s->pc++);
            gen_enter(s, val, level);
        }
        break;
    case 0xc9:

        if (((s)->code64)) {
            gen_op_mov_TN_reg(OT_QUAD, 0, 5);
            gen_op_mov_reg_T0(OT_QUAD, 4);
        } else if (s->ss32) {
            gen_op_mov_TN_reg(OT_LONG, 0, 5);
            gen_op_mov_reg_T0(OT_LONG, 4);
        } else {
            gen_op_mov_TN_reg(OT_WORD, 0, 5);
            gen_op_mov_reg_T0(OT_WORD, 4);
        }
        gen_pop_T0(s);
        if (((s)->code64)) {
            ot = dflag ? OT_QUAD : OT_WORD;
        } else {
            ot = dflag + OT_WORD;
        }
        gen_op_mov_reg_T0(ot, 5);
        gen_pop_update(s);
        break;
    case 0x06:
    case 0x0e:
    case 0x16:
    case 0x1e:
        if (((s)->code64))
            goto illegal_op;
        gen_op_movl_T0_seg(b >> 3);
        gen_push_T0(s);
        break;
    case 0x1a0:
    case 0x1a8:
        gen_op_movl_T0_seg((b >> 3) & 7);
        gen_push_T0(s);
        break;
    case 0x07:
    case 0x17:
    case 0x1f:
        if (((s)->code64))
            goto illegal_op;
        reg = b >> 3;
        gen_pop_T0(s);
        gen_movl_seg_T0(s, reg, pc_start - s->cs_base);
        gen_pop_update(s);
        if (reg == 2) {



            if (!(s->tb->flags & (1 << 3)))
                gen_helper_set_inhibit_irq();
            s->tf = 0;
        }
        if (s->is_jmp) {
            gen_jmp_im(s->pc - s->cs_base);
            gen_eob(s);
        }
        break;
    case 0x1a1:
    case 0x1a9:
        gen_pop_T0(s);
        gen_movl_seg_T0(s, (b >> 3) & 7, pc_start - s->cs_base);
        gen_pop_update(s);
        if (s->is_jmp) {
            gen_jmp_im(s->pc - s->cs_base);
            gen_eob(s);
        }
        break;



    case 0x88:
    case 0x89:
        if ((b & 1) == 0)
            ot = OT_BYTE;
        else
            ot = dflag + OT_WORD;
        modrm = ldub_code(s->pc++);
        reg = ((modrm >> 3) & 7) | rex_r;


        gen_ldst_modrm(s, modrm, ot, reg, 1);
        break;
    case 0xc6:
    case 0xc7:
        if ((b & 1) == 0)
            ot = OT_BYTE;
        else
            ot = dflag + OT_WORD;
        modrm = ldub_code(s->pc++);
        mod = (modrm >> 6) & 3;
        if (mod != 3) {
            s->rip_offset = insn_const_size(ot);
            gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
        }
        val = insn_get(s, ot);
        gen_op_movl_T0_im(val);
        if (mod != 3)
            gen_op_st_T0_A0(ot + s->mem_index);
        else
            gen_op_mov_reg_T0(ot, (modrm & 7) | ((s)->rex_b));
        break;
    case 0x8a:
    case 0x8b:
        if ((b & 1) == 0)
            ot = OT_BYTE;
        else
            ot = OT_WORD + dflag;
        modrm = ldub_code(s->pc++);
        reg = ((modrm >> 3) & 7) | rex_r;

        gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
        gen_op_mov_reg_T0(ot, reg);
        break;
    case 0x8e:
        modrm = ldub_code(s->pc++);
        reg = (modrm >> 3) & 7;
        if (reg >= 6 || reg == 1)
            goto illegal_op;
        gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
        gen_movl_seg_T0(s, reg, pc_start - s->cs_base);
        if (reg == 2) {



            if (!(s->tb->flags & (1 << 3)))
                gen_helper_set_inhibit_irq();
            s->tf = 0;
        }
        if (s->is_jmp) {
            gen_jmp_im(s->pc - s->cs_base);
            gen_eob(s);
        }
        break;
    case 0x8c:
        modrm = ldub_code(s->pc++);
        reg = (modrm >> 3) & 7;
        mod = (modrm >> 6) & 3;
        if (reg >= 6)
            goto illegal_op;
        gen_op_movl_T0_seg(reg);
        if (mod == 3)
            ot = OT_WORD + dflag;
        else
            ot = OT_WORD;
        gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
        break;

    case 0x1b6:
    case 0x1b7:
    case 0x1be:
    case 0x1bf:
        {
            int d_ot;

            d_ot = dflag + OT_WORD;

            ot = (b & 1) + OT_BYTE;
            modrm = ldub_code(s->pc++);
            reg = ((modrm >> 3) & 7) | rex_r;
            mod = (modrm >> 6) & 3;
            rm = (modrm & 7) | ((s)->rex_b);

            if (mod == 3) {
                gen_op_mov_TN_reg(ot, 0, rm);
                switch(ot | (b & 8)) {
                case OT_BYTE:
                    tcg_gen_ext8u_i64(cpu_T[0], cpu_T[0]);
                    break;
                case OT_BYTE | 8:
                    tcg_gen_ext8s_i64(cpu_T[0], cpu_T[0]);
                    break;
                case OT_WORD:
                    tcg_gen_ext16u_i64(cpu_T[0], cpu_T[0]);
                    break;
                default:
                case OT_WORD | 8:
                    tcg_gen_ext16s_i64(cpu_T[0], cpu_T[0]);
                    break;
                }
                gen_op_mov_reg_T0(d_ot, reg);
            } else {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                if (b & 8) {
                    gen_op_lds_T0_A0(ot + s->mem_index);
                } else {
                    gen_op_ldu_T0_A0(ot + s->mem_index);
                }
                gen_op_mov_reg_T0(d_ot, reg);
            }
        }
        break;

    case 0x8d:
        ot = dflag + OT_WORD;
        modrm = ldub_code(s->pc++);
        mod = (modrm >> 6) & 3;
        if (mod == 3)
            goto illegal_op;
        reg = ((modrm >> 3) & 7) | rex_r;

        s->override = -1;
        val = s->addseg;
        s->addseg = 0;
        gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
        s->addseg = val;
        gen_op_mov_reg_A0(ot - OT_WORD, reg);
        break;

    case 0xa0:
    case 0xa1:
    case 0xa2:
    case 0xa3:
        {
            target_ulong offset_addr;

            if ((b & 1) == 0)
                ot = OT_BYTE;
            else
                ot = dflag + OT_WORD;

            if (s->aflag == 2) {
                offset_addr = ldq_code(s->pc);
                s->pc += 8;
                gen_op_movq_A0_im(offset_addr);
            } else

            {
                if (s->aflag) {
                    offset_addr = insn_get(s, OT_LONG);
                } else {
                    offset_addr = insn_get(s, OT_WORD);
                }
                gen_op_movl_A0_im(offset_addr);
            }
            gen_add_A0_ds_seg(s);
            if ((b & 2) == 0) {
                gen_op_ld_T0_A0(ot + s->mem_index);
                gen_op_mov_reg_T0(ot, 0);
            } else {
                gen_op_mov_TN_reg(ot, 0, 0);
                gen_op_st_T0_A0(ot + s->mem_index);
            }
        }
        break;
    case 0xd7:

        if (s->aflag == 2) {
            gen_op_movq_A0_reg(3);
            gen_op_mov_TN_reg(OT_QUAD, 0, 0);
            tcg_gen_andi_i64(cpu_T[0], cpu_T[0], 0xff);
            tcg_gen_add_i64(cpu_A0, cpu_A0, cpu_T[0]);
        } else

        {
            gen_op_movl_A0_reg(3);
            gen_op_mov_TN_reg(OT_LONG, 0, 0);
            tcg_gen_andi_i64(cpu_T[0], cpu_T[0], 0xff);
            tcg_gen_add_i64(cpu_A0, cpu_A0, cpu_T[0]);
            if (s->aflag == 0)
                gen_op_andl_A0_ffff();
            else
                tcg_gen_andi_i64(cpu_A0, cpu_A0, 0xffffffff);
        }
        gen_add_A0_ds_seg(s);
        gen_op_ldu_T0_A0(OT_BYTE + s->mem_index);
        gen_op_mov_reg_T0(OT_BYTE, 0);
        break;
    case 0xb0 ... 0xb7:
        val = insn_get(s, OT_BYTE);
        gen_op_movl_T0_im(val);
        gen_op_mov_reg_T0(OT_BYTE, (b & 7) | ((s)->rex_b));
        break;
    case 0xb8 ... 0xbf:

        if (dflag == 2) {
            uint64_t tmp;

            tmp = ldq_code(s->pc);
            s->pc += 8;
            reg = (b & 7) | ((s)->rex_b);
            gen_movtl_T0_im(tmp);
            gen_op_mov_reg_T0(OT_QUAD, reg);
        } else

        {
            ot = dflag ? OT_LONG : OT_WORD;
            val = insn_get(s, ot);
            reg = (b & 7) | ((s)->rex_b);
            gen_op_movl_T0_im(val);
            gen_op_mov_reg_T0(ot, reg);
        }
        break;

    case 0x91 ... 0x97:
    do_xchg_reg_eax:
        ot = dflag + OT_WORD;
        reg = (b & 7) | ((s)->rex_b);
        rm = 0;
        goto do_xchg_reg;
    case 0x86:
    case 0x87:
        if ((b & 1) == 0)
            ot = OT_BYTE;
        else
            ot = dflag + OT_WORD;
        modrm = ldub_code(s->pc++);
        reg = ((modrm >> 3) & 7) | rex_r;
        mod = (modrm >> 6) & 3;
        if (mod == 3) {
            rm = (modrm & 7) | ((s)->rex_b);
        do_xchg_reg:
            gen_op_mov_TN_reg(ot, 0, reg);
            gen_op_mov_TN_reg(ot, 1, rm);
            gen_op_mov_reg_T0(ot, rm);
            gen_op_mov_reg_T1(ot, reg);
        } else {
            gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
            gen_op_mov_TN_reg(ot, 0, reg);

            if (!(prefixes & 0x04))
                gen_helper_lock();
            gen_op_ld_T1_A0(ot + s->mem_index);
            gen_op_st_T0_A0(ot + s->mem_index);
            if (!(prefixes & 0x04))
                gen_helper_unlock();
            gen_op_mov_reg_T1(ot, reg);
        }
        break;
    case 0xc4:
        if (((s)->code64))
            goto illegal_op;
        op = 0;
        goto do_lxx;
    case 0xc5:
        if (((s)->code64))
            goto illegal_op;
        op = 3;
        goto do_lxx;
    case 0x1b2:
        op = 2;
        goto do_lxx;
    case 0x1b4:
        op = 4;
        goto do_lxx;
    case 0x1b5:
        op = 5;
    do_lxx:
        ot = dflag ? OT_LONG : OT_WORD;
        modrm = ldub_code(s->pc++);
        reg = ((modrm >> 3) & 7) | rex_r;
        mod = (modrm >> 6) & 3;
        if (mod == 3)
            goto illegal_op;
        gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
        gen_op_ld_T1_A0(ot + s->mem_index);
        gen_add_A0_im(s, 1 << (ot - OT_WORD + 1));

        gen_op_ldu_T0_A0(OT_WORD + s->mem_index);
        gen_movl_seg_T0(s, op, pc_start - s->cs_base);

        gen_op_mov_reg_T1(ot, reg);
        if (s->is_jmp) {
            gen_jmp_im(s->pc - s->cs_base);
            gen_eob(s);
        }
        break;



    case 0xc0:
    case 0xc1:

        shift = 2;
    grp2:
        {
            if ((b & 1) == 0)
                ot = OT_BYTE;
            else
                ot = dflag + OT_WORD;

            modrm = ldub_code(s->pc++);
            mod = (modrm >> 6) & 3;
            op = (modrm >> 3) & 7;

            if (mod != 3) {
                if (shift == 2) {
                    s->rip_offset = 1;
                }
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                opreg = OR_TMP0;
            } else {
                opreg = (modrm & 7) | ((s)->rex_b);
            }


            if (shift == 0) {
                gen_shift(s, op, ot, opreg, OR_ECX);
            } else {
                if (shift == 2) {
                    shift = ldub_code(s->pc++);
                }
                gen_shifti(s, op, ot, opreg, shift);
            }
        }
        break;
    case 0xd0:
    case 0xd1:

        shift = 1;
        goto grp2;
    case 0xd2:
    case 0xd3:

        shift = 0;
        goto grp2;

    case 0x1a4:
        op = 0;
        shift = 1;
        goto do_shiftd;
    case 0x1a5:
        op = 0;
        shift = 0;
        goto do_shiftd;
    case 0x1ac:
        op = 1;
        shift = 1;
        goto do_shiftd;
    case 0x1ad:
        op = 1;
        shift = 0;
    do_shiftd:
        ot = dflag + OT_WORD;
        modrm = ldub_code(s->pc++);
        mod = (modrm >> 6) & 3;
        rm = (modrm & 7) | ((s)->rex_b);
        reg = ((modrm >> 3) & 7) | rex_r;
        if (mod != 3) {
            gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
            opreg = OR_TMP0;
        } else {
            opreg = rm;
        }
        gen_op_mov_TN_reg(ot, 1, reg);

        if (shift) {
            val = ldub_code(s->pc++);
            tcg_gen_movi_i64(cpu_T3, val);
        } else {
            tcg_gen_mov_i64(cpu_T3, cpu_regs[1]);
        }
        gen_shiftd_rm_T1_T3(s, ot, opreg, op);
        break;



    case 0xd8 ... 0xdf:
        if (s->flags & ((1 << 10) | (1 << 11))) {


            gen_exception(s, 7, pc_start - s->cs_base);
            break;
        }
        modrm = ldub_code(s->pc++);
        mod = (modrm >> 6) & 3;
        rm = modrm & 7;
        op = ((b & 7) << 3) | ((modrm >> 3) & 7);
        if (mod != 3) {

            gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
            switch(op) {
            case 0x00 ... 0x07:
            case 0x10 ... 0x17:
            case 0x20 ... 0x27:
            case 0x30 ... 0x37:
                {
                    int op1;
                    op1 = op & 7;

                    switch(op >> 4) {
                    case 0:
                        gen_op_ld_T0_A0(OT_LONG + s->mem_index);
                        tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
                        gen_helper_flds_FT0(cpu_tmp2_i32);
                        break;
                    case 1:
                        gen_op_ld_T0_A0(OT_LONG + s->mem_index);
                        tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
                        gen_helper_fildl_FT0(cpu_tmp2_i32);
                        break;
                    case 2:
                        tcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0,
                                          (s->mem_index >> 2) - 1);
                        gen_helper_fldl_FT0(cpu_tmp1_i64);
                        break;
                    case 3:
                    default:
                        gen_op_lds_T0_A0(OT_WORD + s->mem_index);
                        tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
                        gen_helper_fildl_FT0(cpu_tmp2_i32);
                        break;
                    }

                    gen_helper_fp_arith_ST0_FT0(op1);
                    if (op1 == 3) {

                        gen_helper_fpop();
                    }
                }
                break;
            case 0x08:
            case 0x0a:
            case 0x0b:
            case 0x18 ... 0x1b:
            case 0x28 ... 0x2b:
            case 0x38 ... 0x3b:
                switch(op & 7) {
                case 0:
                    switch(op >> 4) {
                    case 0:
                        gen_op_ld_T0_A0(OT_LONG + s->mem_index);
                        tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
                        gen_helper_flds_ST0(cpu_tmp2_i32);
                        break;
                    case 1:
                        gen_op_ld_T0_A0(OT_LONG + s->mem_index);
                        tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
                        gen_helper_fildl_ST0(cpu_tmp2_i32);
                        break;
                    case 2:
                        tcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0,
                                          (s->mem_index >> 2) - 1);
                        gen_helper_fldl_ST0(cpu_tmp1_i64);
                        break;
                    case 3:
                    default:
                        gen_op_lds_T0_A0(OT_WORD + s->mem_index);
                        tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
                        gen_helper_fildl_ST0(cpu_tmp2_i32);
                        break;
                    }
                    break;
                case 1:

                    switch(op >> 4) {
                    case 1:
                        gen_helper_fisttl_ST0(cpu_tmp2_i32);
                        tcg_gen_extu_i32_i64(cpu_T[0], cpu_tmp2_i32);
                        gen_op_st_T0_A0(OT_LONG + s->mem_index);
                        break;
                    case 2:
                        gen_helper_fisttll_ST0(cpu_tmp1_i64);
                        tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0,
                                          (s->mem_index >> 2) - 1);
                        break;
                    case 3:
                    default:
                        gen_helper_fistt_ST0(cpu_tmp2_i32);
                        tcg_gen_extu_i32_i64(cpu_T[0], cpu_tmp2_i32);
                        gen_op_st_T0_A0(OT_WORD + s->mem_index);
                        break;
                    }
                    gen_helper_fpop();
                    break;
                default:
                    switch(op >> 4) {
                    case 0:
                        gen_helper_fsts_ST0(cpu_tmp2_i32);
                        tcg_gen_extu_i32_i64(cpu_T[0], cpu_tmp2_i32);
                        gen_op_st_T0_A0(OT_LONG + s->mem_index);
                        break;
                    case 1:
                        gen_helper_fistl_ST0(cpu_tmp2_i32);
                        tcg_gen_extu_i32_i64(cpu_T[0], cpu_tmp2_i32);
                        gen_op_st_T0_A0(OT_LONG + s->mem_index);
                        break;
                    case 2:
                        gen_helper_fstl_ST0(cpu_tmp1_i64);
                        tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0,
                                          (s->mem_index >> 2) - 1);
                        break;
                    case 3:
                    default:
                        gen_helper_fist_ST0(cpu_tmp2_i32);
                        tcg_gen_extu_i32_i64(cpu_T[0], cpu_tmp2_i32);
                        gen_op_st_T0_A0(OT_WORD + s->mem_index);
                        break;
                    }
                    if ((op & 7) == 3)
                        gen_helper_fpop();
                    break;
                }
                break;
            case 0x0c:
                if (s->cc_op != CC_OP_DYNAMIC)
                    gen_op_set_cc_op(s->cc_op);
                gen_jmp_im(pc_start - s->cs_base);
                gen_helper_fldenv(
                                   cpu_A0, tcg_const_i32(s->dflag));
                break;
            case 0x0d:
                gen_op_ld_T0_A0(OT_WORD + s->mem_index);
                tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
                gen_helper_fldcw(cpu_tmp2_i32);
                break;
            case 0x0e:
                if (s->cc_op != CC_OP_DYNAMIC)
                    gen_op_set_cc_op(s->cc_op);
                gen_jmp_im(pc_start - s->cs_base);
                gen_helper_fstenv(cpu_A0, tcg_const_i32(s->dflag));
                break;
            case 0x0f:
                gen_helper_fnstcw(cpu_tmp2_i32);
                tcg_gen_extu_i32_i64(cpu_T[0], cpu_tmp2_i32);
                gen_op_st_T0_A0(OT_WORD + s->mem_index);
                break;
            case 0x1d:
                if (s->cc_op != CC_OP_DYNAMIC)
                    gen_op_set_cc_op(s->cc_op);
                gen_jmp_im(pc_start - s->cs_base);
                gen_helper_fldt_ST0(cpu_A0);
                break;
            case 0x1f:
                if (s->cc_op != CC_OP_DYNAMIC)
                    gen_op_set_cc_op(s->cc_op);
                gen_jmp_im(pc_start - s->cs_base);
                gen_helper_fstt_ST0(cpu_A0);
                gen_helper_fpop();
                break;
            case 0x2c:
                if (s->cc_op != CC_OP_DYNAMIC)
                    gen_op_set_cc_op(s->cc_op);
                gen_jmp_im(pc_start - s->cs_base);
                gen_helper_frstor(cpu_A0, tcg_const_i32(s->dflag));
                break;
            case 0x2e:
                if (s->cc_op != CC_OP_DYNAMIC)
                    gen_op_set_cc_op(s->cc_op);
                gen_jmp_im(pc_start - s->cs_base);
                gen_helper_fsave(cpu_A0, tcg_const_i32(s->dflag));
                break;
            case 0x2f:
                gen_helper_fnstsw(cpu_tmp2_i32);
                tcg_gen_extu_i32_i64(cpu_T[0], cpu_tmp2_i32);
                gen_op_st_T0_A0(OT_WORD + s->mem_index);
                break;
            case 0x3c:
                if (s->cc_op != CC_OP_DYNAMIC)
                    gen_op_set_cc_op(s->cc_op);
                gen_jmp_im(pc_start - s->cs_base);
                gen_helper_fbld_ST0(cpu_A0);
                break;
            case 0x3e:
                if (s->cc_op != CC_OP_DYNAMIC)
                    gen_op_set_cc_op(s->cc_op);
                gen_jmp_im(pc_start - s->cs_base);
                gen_helper_fbst_ST0(cpu_A0);
                gen_helper_fpop();
                break;
            case 0x3d:
                tcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0,
                                  (s->mem_index >> 2) - 1);
                gen_helper_fildll_ST0(cpu_tmp1_i64);
                break;
            case 0x3f:
                gen_helper_fistll_ST0(cpu_tmp1_i64);
                tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0,
                                  (s->mem_index >> 2) - 1);
                gen_helper_fpop();
                break;
            default:
                goto illegal_op;
            }
        } else {

            opreg = rm;

            switch(op) {
            case 0x08:
                gen_helper_fpush();
                gen_helper_fmov_ST0_STN(tcg_const_i32((opreg + 1) & 7));
                break;
            case 0x09:
            case 0x29:
            case 0x39:
                gen_helper_fxchg_ST0_STN(tcg_const_i32(opreg));
                break;
            case 0x0a:
                switch(rm) {
                case 0:

                    if (s->cc_op != CC_OP_DYNAMIC)
                        gen_op_set_cc_op(s->cc_op);
                    gen_jmp_im(pc_start - s->cs_base);
                    gen_helper_fwait();
                    break;
                default:
                    goto illegal_op;
                }
                break;
            case 0x0c:
                switch(rm) {
                case 0:
                    gen_helper_fchs_ST0();
                    break;
                case 1:
                    gen_helper_fabs_ST0();
                    break;
                case 4:
                    gen_helper_fldz_FT0();
                    gen_helper_fcom_ST0_FT0();
                    break;
                case 5:
                    gen_helper_fxam_ST0();
                    break;
                default:
                    goto illegal_op;
                }
                break;
            case 0x0d:
                {
                    switch(rm) {
                    case 0:
                        gen_helper_fpush();
                        gen_helper_fld1_ST0();
                        break;
                    case 1:
                        gen_helper_fpush();
                        gen_helper_fldl2t_ST0();
                        break;
                    case 2:
                        gen_helper_fpush();
                        gen_helper_fldl2e_ST0();
                        break;
                    case 3:
                        gen_helper_fpush();
                        gen_helper_fldpi_ST0();
                        break;
                    case 4:
                        gen_helper_fpush();
                        gen_helper_fldlg2_ST0();
                        break;
                    case 5:
                        gen_helper_fpush();
                        gen_helper_fldln2_ST0();
                        break;
                    case 6:
                        gen_helper_fpush();
                        gen_helper_fldz_ST0();
                        break;
                    default:
                        goto illegal_op;
                    }
                }
                break;
            case 0x0e:
                switch(rm) {
                case 0:
                    gen_helper_f2xm1();
                    break;
                case 1:
                    gen_helper_fyl2x();
                    break;
                case 2:
                    gen_helper_fptan();
                    break;
                case 3:
                    gen_helper_fpatan();
                    break;
                case 4:
                    gen_helper_fxtract();
                    break;
                case 5:
                    gen_helper_fprem1();
                    break;
                case 6:
                    gen_helper_fdecstp();
                    break;
                default:
                case 7:
                    gen_helper_fincstp();
                    break;
                }
                break;
            case 0x0f:
                switch(rm) {
                case 0:
                    gen_helper_fprem();
                    break;
                case 1:
                    gen_helper_fyl2xp1();
                    break;
                case 2:
                    gen_helper_fsqrt();
                    break;
                case 3:
                    gen_helper_fsincos();
                    break;
                case 5:
                    gen_helper_fscale();
                    break;
                case 4:
                    gen_helper_frndint();
                    break;
                case 6:
                    gen_helper_fsin();
                    break;
                default:
                case 7:
                    gen_helper_fcos();
                    break;
                }
                break;
            case 0x00: case 0x01: case 0x04 ... 0x07:
            case 0x20: case 0x21: case 0x24 ... 0x27:
            case 0x30: case 0x31: case 0x34 ... 0x37:
                {
                    int op1;

                    op1 = op & 7;
                    if (op >= 0x20) {
                        gen_helper_fp_arith_STN_ST0(op1, opreg);
                        if (op >= 0x30)
                            gen_helper_fpop();
                    } else {
                        gen_helper_fmov_FT0_STN(tcg_const_i32(opreg));
                        gen_helper_fp_arith_ST0_FT0(op1);
                    }
                }
                break;
            case 0x02:
            case 0x22:
                gen_helper_fmov_FT0_STN(tcg_const_i32(opreg));
                gen_helper_fcom_ST0_FT0();
                break;
            case 0x03:
            case 0x23:
            case 0x32:
                gen_helper_fmov_FT0_STN(tcg_const_i32(opreg));
                gen_helper_fcom_ST0_FT0();
                gen_helper_fpop();
                break;
            case 0x15:
                switch(rm) {
                case 1:
                    gen_helper_fmov_FT0_STN(tcg_const_i32(1));
                    gen_helper_fucom_ST0_FT0();
                    gen_helper_fpop();
                    gen_helper_fpop();
                    break;
                default:
                    goto illegal_op;
                }
                break;
            case 0x1c:
                switch(rm) {
                case 0:
                    break;
                case 1:
                    break;
                case 2:
                    gen_helper_fclex();
                    break;
                case 3:
                    gen_helper_fninit();
                    break;
                case 4:
                    break;
                default:
                    goto illegal_op;
                }
                break;
            case 0x1d:
                if (s->cc_op != CC_OP_DYNAMIC)
                    gen_op_set_cc_op(s->cc_op);
                gen_helper_fmov_FT0_STN(tcg_const_i32(opreg));
                gen_helper_fucomi_ST0_FT0();
                s->cc_op = CC_OP_EFLAGS;
                break;
            case 0x1e:
                if (s->cc_op != CC_OP_DYNAMIC)
                    gen_op_set_cc_op(s->cc_op);
                gen_helper_fmov_FT0_STN(tcg_const_i32(opreg));
                gen_helper_fcomi_ST0_FT0();
                s->cc_op = CC_OP_EFLAGS;
                break;
            case 0x28:
                gen_helper_ffree_STN(tcg_const_i32(opreg));
                break;
            case 0x2a:
                gen_helper_fmov_STN_ST0(tcg_const_i32(opreg));
                break;
            case 0x2b:
            case 0x0b:
            case 0x3a:
            case 0x3b:
                gen_helper_fmov_STN_ST0(tcg_const_i32(opreg));
                gen_helper_fpop();
                break;
            case 0x2c:
                gen_helper_fmov_FT0_STN(tcg_const_i32(opreg));
                gen_helper_fucom_ST0_FT0();
                break;
            case 0x2d:
                gen_helper_fmov_FT0_STN(tcg_const_i32(opreg));
                gen_helper_fucom_ST0_FT0();
                gen_helper_fpop();
                break;
            case 0x33:
                switch(rm) {
                case 1:
                    gen_helper_fmov_FT0_STN(tcg_const_i32(1));
                    gen_helper_fcom_ST0_FT0();
                    gen_helper_fpop();
                    gen_helper_fpop();
                    break;
                default:
                    goto illegal_op;
                }
                break;
            case 0x38:
                gen_helper_ffree_STN(tcg_const_i32(opreg));
                gen_helper_fpop();
                break;
            case 0x3c:
                switch(rm) {
                case 0:
                    gen_helper_fnstsw(cpu_tmp2_i32);
                    tcg_gen_extu_i32_i64(cpu_T[0], cpu_tmp2_i32);
                    gen_op_mov_reg_T0(OT_WORD, 0);
                    break;
                default:
                    goto illegal_op;
                }
                break;
            case 0x3d:
                if (s->cc_op != CC_OP_DYNAMIC)
                    gen_op_set_cc_op(s->cc_op);
                gen_helper_fmov_FT0_STN(tcg_const_i32(opreg));
                gen_helper_fucomi_ST0_FT0();
                gen_helper_fpop();
                s->cc_op = CC_OP_EFLAGS;
                break;
            case 0x3e:
                if (s->cc_op != CC_OP_DYNAMIC)
                    gen_op_set_cc_op(s->cc_op);
                gen_helper_fmov_FT0_STN(tcg_const_i32(opreg));
                gen_helper_fcomi_ST0_FT0();
                gen_helper_fpop();
                s->cc_op = CC_OP_EFLAGS;
                break;
            case 0x10 ... 0x13:
            case 0x18 ... 0x1b:
                {
                    int op1, l1;
                    static const uint8_t fcmov_cc[8] = {
                        (JCC_B << 1),
                        (JCC_Z << 1),
                        (JCC_BE << 1),
                        (JCC_P << 1),
                    };
                    op1 = fcmov_cc[op & 3] | (((op >> 3) & 1) ^ 1);
                    l1 = gen_new_label();
                    gen_jcc1(s, s->cc_op, op1, l1);
                    gen_helper_fmov_ST0_STN(tcg_const_i32(opreg));
                    gen_set_label(l1);
                }
                break;
            default:
                goto illegal_op;
            }
        }
        break;



    case 0xa4:
    case 0xa5:
        if ((b & 1) == 0)
            ot = OT_BYTE;
        else
            ot = dflag + OT_WORD;

        if (prefixes & (0x01 | 0x02)) {
            gen_repz_movs(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
        } else {
            gen_movs(s, ot);
        }
        break;

    case 0xaa:
    case 0xab:
        if ((b & 1) == 0)
            ot = OT_BYTE;
        else
            ot = dflag + OT_WORD;

        if (prefixes & (0x01 | 0x02)) {
            gen_repz_stos(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
        } else {
            gen_stos(s, ot);
        }
        break;
    case 0xac:
    case 0xad:
        if ((b & 1) == 0)
            ot = OT_BYTE;
        else
            ot = dflag + OT_WORD;
        if (prefixes & (0x01 | 0x02)) {
            gen_repz_lods(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
        } else {
            gen_lods(s, ot);
        }
        break;
    case 0xae:
    case 0xaf:
        if ((b & 1) == 0)
            ot = OT_BYTE;
        else
            ot = dflag + OT_WORD;
        if (prefixes & 0x02) {
            gen_repz_scas(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 1);
        } else if (prefixes & 0x01) {
            gen_repz_scas(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 0);
        } else {
            gen_scas(s, ot);
            s->cc_op = CC_OP_SUBB + ot;
        }
        break;

    case 0xa6:
    case 0xa7:
        if ((b & 1) == 0)
            ot = OT_BYTE;
        else
            ot = dflag + OT_WORD;
        if (prefixes & 0x02) {
            gen_repz_cmps(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 1);
        } else if (prefixes & 0x01) {
            gen_repz_cmps(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 0);
        } else {
            gen_cmps(s, ot);
            s->cc_op = CC_OP_SUBB + ot;
        }
        break;
    case 0x6c:
    case 0x6d:
        if ((b & 1) == 0)
            ot = OT_BYTE;
        else
            ot = dflag ? OT_LONG : OT_WORD;
        gen_op_mov_TN_reg(OT_WORD, 0, 2);
        gen_op_andl_T0_ffff();
        gen_check_io(s, ot, pc_start - s->cs_base,
                     1 | svm_is_rep(prefixes) | 4);
        if (prefixes & (0x01 | 0x02)) {
            gen_repz_ins(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
        } else {
            gen_ins(s, ot);
            if (use_icount) {
                gen_jmp(s, s->pc - s->cs_base);
            }
        }
        break;
    case 0x6e:
    case 0x6f:
        if ((b & 1) == 0)
            ot = OT_BYTE;
        else
            ot = dflag ? OT_LONG : OT_WORD;
        gen_op_mov_TN_reg(OT_WORD, 0, 2);
        gen_op_andl_T0_ffff();
        gen_check_io(s, ot, pc_start - s->cs_base,
                     svm_is_rep(prefixes) | 4);
        if (prefixes & (0x01 | 0x02)) {
            gen_repz_outs(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
        } else {
            gen_outs(s, ot);
            if (use_icount) {
                gen_jmp(s, s->pc - s->cs_base);
            }
        }
        break;




    case 0xe4:
    case 0xe5:
        if ((b & 1) == 0)
            ot = OT_BYTE;
        else
            ot = dflag ? OT_LONG : OT_WORD;
        val = ldub_code(s->pc++);
        gen_op_movl_T0_im(val);
        gen_check_io(s, ot, pc_start - s->cs_base,
                     1 | svm_is_rep(prefixes));
        if (use_icount)
            gen_io_start();
        tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
        gen_helper_in_func(ot, cpu_T[1], cpu_tmp2_i32);
        gen_op_mov_reg_T1(ot, 0);
        if (use_icount) {
            gen_io_end();
            gen_jmp(s, s->pc - s->cs_base);
        }
        break;
    case 0xe6:
    case 0xe7:
        if ((b & 1) == 0)
            ot = OT_BYTE;
        else
            ot = dflag ? OT_LONG : OT_WORD;
        val = ldub_code(s->pc++);
        gen_op_movl_T0_im(val);
        gen_check_io(s, ot, pc_start - s->cs_base,
                     svm_is_rep(prefixes));
        gen_op_mov_TN_reg(ot, 1, 0);

        if (use_icount)
            gen_io_start();
        tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
        tcg_gen_andi_i32(cpu_tmp2_i32, cpu_tmp2_i32, 0xffff);
        tcg_gen_trunc_i64_i32(cpu_tmp3_i32, cpu_T[1]);
        gen_helper_out_func(ot, cpu_tmp2_i32, cpu_tmp3_i32);
        if (use_icount) {
            gen_io_end();
            gen_jmp(s, s->pc - s->cs_base);
        }
        break;
    case 0xec:
    case 0xed:
        if ((b & 1) == 0)
            ot = OT_BYTE;
        else
            ot = dflag ? OT_LONG : OT_WORD;
        gen_op_mov_TN_reg(OT_WORD, 0, 2);
        gen_op_andl_T0_ffff();
        gen_check_io(s, ot, pc_start - s->cs_base,
                     1 | svm_is_rep(prefixes));
        if (use_icount)
            gen_io_start();
        tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
        gen_helper_in_func(ot, cpu_T[1], cpu_tmp2_i32);
        gen_op_mov_reg_T1(ot, 0);
        if (use_icount) {
            gen_io_end();
            gen_jmp(s, s->pc - s->cs_base);
        }
        break;
    case 0xee:
    case 0xef:
        if ((b & 1) == 0)
            ot = OT_BYTE;
        else
            ot = dflag ? OT_LONG : OT_WORD;
        gen_op_mov_TN_reg(OT_WORD, 0, 2);
        gen_op_andl_T0_ffff();
        gen_check_io(s, ot, pc_start - s->cs_base,
                     svm_is_rep(prefixes));
        gen_op_mov_TN_reg(ot, 1, 0);

        if (use_icount)
            gen_io_start();
        tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
        tcg_gen_andi_i32(cpu_tmp2_i32, cpu_tmp2_i32, 0xffff);
        tcg_gen_trunc_i64_i32(cpu_tmp3_i32, cpu_T[1]);
        gen_helper_out_func(ot, cpu_tmp2_i32, cpu_tmp3_i32);
        if (use_icount) {
            gen_io_end();
            gen_jmp(s, s->pc - s->cs_base);
        }
        break;



    case 0xc2:
        val = ldsw_code(s->pc);
        s->pc += 2;
        gen_pop_T0(s);
        if (((s)->code64) && s->dflag)
            s->dflag = 2;
        gen_stack_update(s, val + (2 << s->dflag));
        if (s->dflag == 0)
            gen_op_andl_T0_ffff();
        gen_op_jmp_T0();
        gen_eob(s);
        break;
    case 0xc3:
        gen_pop_T0(s);
        gen_pop_update(s);
        if (s->dflag == 0)
            gen_op_andl_T0_ffff();
        gen_op_jmp_T0();
        gen_eob(s);
        break;
    case 0xca:
        val = ldsw_code(s->pc);
        s->pc += 2;
    do_lret:
        if (s->pe && !s->vm86) {
            if (s->cc_op != CC_OP_DYNAMIC)
                gen_op_set_cc_op(s->cc_op);
            gen_jmp_im(pc_start - s->cs_base);
            gen_helper_lret_protected(tcg_const_i32(s->dflag),
                                      tcg_const_i32(val));
        } else {
            gen_stack_A0(s);

            gen_op_ld_T0_A0(1 + s->dflag + s->mem_index);
            if (s->dflag == 0)
                gen_op_andl_T0_ffff();


            gen_op_jmp_T0();

            gen_op_addl_A0_im(2 << s->dflag);
            gen_op_ld_T0_A0(1 + s->dflag + s->mem_index);
            gen_op_movl_seg_T0_vm(1);

            gen_stack_update(s, val + (4 << s->dflag));
        }
        gen_eob(s);
        break;
    case 0xcb:
        val = 0;
        goto do_lret;
    case 0xcf:
        gen_svm_check_intercept(s, pc_start, 0x074);
        if (!s->pe) {

            gen_helper_iret_real(tcg_const_i32(s->dflag));
            s->cc_op = CC_OP_EFLAGS;
        } else if (s->vm86) {
            if (s->iopl != 3) {
                gen_exception(s, 13, pc_start - s->cs_base);
            } else {
                gen_helper_iret_real(tcg_const_i32(s->dflag));
                s->cc_op = CC_OP_EFLAGS;
            }
        } else {
            if (s->cc_op != CC_OP_DYNAMIC)
                gen_op_set_cc_op(s->cc_op);
            gen_jmp_im(pc_start - s->cs_base);
            gen_helper_iret_protected(tcg_const_i32(s->dflag),
                                      tcg_const_i32(s->pc - s->cs_base));
            s->cc_op = CC_OP_EFLAGS;
        }
        gen_eob(s);
        break;
    case 0xe8:
        {
            if (dflag)
                tval = (int32_t)insn_get(s, OT_LONG);
            else
                tval = (int16_t)insn_get(s, OT_WORD);
            next_eip = s->pc - s->cs_base;
            tval += next_eip;
            if (s->dflag == 0)
                tval &= 0xffff;
            else if(!((s)->code64))
                tval &= 0xffffffff;
            gen_movtl_T0_im(next_eip);
            gen_push_T0(s);
            gen_jmp(s, tval);
        }
        break;
    case 0x9a:
        {
            unsigned int selector, offset;

            if (((s)->code64))
                goto illegal_op;
            ot = dflag ? OT_LONG : OT_WORD;
            offset = insn_get(s, ot);
            selector = insn_get(s, OT_WORD);

            gen_op_movl_T0_im(selector);
            gen_op_movl_T1_imu(offset);
        }
        goto do_lcall;
    case 0xe9:
        if (dflag)
            tval = (int32_t)insn_get(s, OT_LONG);
        else
            tval = (int16_t)insn_get(s, OT_WORD);
        tval += s->pc - s->cs_base;
        if (s->dflag == 0)
            tval &= 0xffff;
        else if(!((s)->code64))
            tval &= 0xffffffff;
        gen_jmp(s, tval);
        break;
    case 0xea:
        {
            unsigned int selector, offset;

            if (((s)->code64))
                goto illegal_op;
            ot = dflag ? OT_LONG : OT_WORD;
            offset = insn_get(s, ot);
            selector = insn_get(s, OT_WORD);

            gen_op_movl_T0_im(selector);
            gen_op_movl_T1_imu(offset);
        }
        goto do_ljmp;
    case 0xeb:
        tval = (int8_t)insn_get(s, OT_BYTE);
        tval += s->pc - s->cs_base;
        if (s->dflag == 0)
            tval &= 0xffff;
        gen_jmp(s, tval);
        break;
    case 0x70 ... 0x7f:
        tval = (int8_t)insn_get(s, OT_BYTE);
        goto do_jcc;
    case 0x180 ... 0x18f:
        if (dflag) {
            tval = (int32_t)insn_get(s, OT_LONG);
        } else {
            tval = (int16_t)insn_get(s, OT_WORD);
        }
    do_jcc:
        next_eip = s->pc - s->cs_base;
        tval += next_eip;
        if (s->dflag == 0)
            tval &= 0xffff;
        gen_jcc(s, b, tval, next_eip);
        break;

    case 0x190 ... 0x19f:
        modrm = ldub_code(s->pc++);
        gen_setcc(s, b);
        gen_ldst_modrm(s, modrm, OT_BYTE, OR_TMP0, 1);
        break;
    case 0x140 ... 0x14f:
        {
            int l1;
            TCGv_i64 t0;

            ot = dflag + OT_WORD;
            modrm = ldub_code(s->pc++);
            reg = ((modrm >> 3) & 7) | rex_r;
            mod = (modrm >> 6) & 3;
            t0 = tcg_temp_local_new_i64();
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                gen_op_ld_v(ot + s->mem_index, t0, cpu_A0);
            } else {
                rm = (modrm & 7) | ((s)->rex_b);
                gen_op_mov_v_reg(ot, t0, rm);
            }

            if (ot == OT_LONG) {

                l1 = gen_new_label();
                gen_jcc1(s, s->cc_op, b ^ 1, l1);
                tcg_gen_mov_i64(cpu_regs[reg], t0);
                gen_set_label(l1);
                tcg_gen_ext32u_i64(cpu_regs[reg], cpu_regs[reg]);
            } else

            {
                l1 = gen_new_label();
                gen_jcc1(s, s->cc_op, b ^ 1, l1);
                gen_op_mov_reg_v(ot, reg, t0);
                gen_set_label(l1);
            }
            tcg_temp_free_i64(t0);
        }
        break;



    case 0x9c:
        gen_svm_check_intercept(s, pc_start, 0x070);
        if (s->vm86 && s->iopl != 3) {
            gen_exception(s, 13, pc_start - s->cs_base);
        } else {
            if (s->cc_op != CC_OP_DYNAMIC)
                gen_op_set_cc_op(s->cc_op);
            gen_helper_read_eflags(cpu_T[0]);
            gen_push_T0(s);
        }
        break;
    case 0x9d:
        gen_svm_check_intercept(s, pc_start, 0x071);
        if (s->vm86 && s->iopl != 3) {
            gen_exception(s, 13, pc_start - s->cs_base);
        } else {
            gen_pop_T0(s);
            if (s->cpl == 0) {
                if (s->dflag) {
                    gen_helper_write_eflags(cpu_T[0],
                                       tcg_const_i32((0x00000100 | 0x00040000 | 0x00200000 | 0x00004000 | 0x00000200 | 0x00003000)));
                } else {
                    gen_helper_write_eflags(cpu_T[0],
                                       tcg_const_i32((0x00000100 | 0x00040000 | 0x00200000 | 0x00004000 | 0x00000200 | 0x00003000) & 0xffff));
                }
            } else {
                if (s->cpl <= s->iopl) {
                    if (s->dflag) {
                        gen_helper_write_eflags(cpu_T[0],
                                           tcg_const_i32((0x00000100 | 0x00040000 | 0x00200000 | 0x00004000 | 0x00000200)));
                    } else {
                        gen_helper_write_eflags(cpu_T[0],
                                           tcg_const_i32((0x00000100 | 0x00040000 | 0x00200000 | 0x00004000 | 0x00000200) & 0xffff));
                    }
                } else {
                    if (s->dflag) {
                        gen_helper_write_eflags(cpu_T[0],
                                           tcg_const_i32((0x00000100 | 0x00040000 | 0x00200000 | 0x00004000)));
                    } else {
                        gen_helper_write_eflags(cpu_T[0],
                                           tcg_const_i32((0x00000100 | 0x00040000 | 0x00200000 | 0x00004000) & 0xffff));
                    }
                }
            }
            gen_pop_update(s);
            s->cc_op = CC_OP_EFLAGS;

            gen_jmp_im(s->pc - s->cs_base);
            gen_eob(s);
        }
        break;
    case 0x9e:
        if (((s)->code64) && !(s->cpuid_ext3_features & (1 << 0)))
            goto illegal_op;
        gen_op_mov_TN_reg(OT_BYTE, 0, 4);
        if (s->cc_op != CC_OP_DYNAMIC)
            gen_op_set_cc_op(s->cc_op);
        gen_compute_eflags(cpu_cc_src);
        tcg_gen_andi_i64(cpu_cc_src, cpu_cc_src, 0x0800);
        tcg_gen_andi_i64(cpu_T[0], cpu_T[0], 0x0080 | 0x0040 | 0x0010 | 0x0004 | 0x0001);
        tcg_gen_or_i64(cpu_cc_src, cpu_cc_src, cpu_T[0]);
        s->cc_op = CC_OP_EFLAGS;
        break;
    case 0x9f:
        if (((s)->code64) && !(s->cpuid_ext3_features & (1 << 0)))
            goto illegal_op;
        if (s->cc_op != CC_OP_DYNAMIC)
            gen_op_set_cc_op(s->cc_op);
        gen_compute_eflags(cpu_T[0]);

        tcg_gen_ori_i64(cpu_T[0], cpu_T[0], 0x02);
        gen_op_mov_reg_T0(OT_BYTE, 4);
        break;
    case 0xf5:
        if (s->cc_op != CC_OP_DYNAMIC)
            gen_op_set_cc_op(s->cc_op);
        gen_compute_eflags(cpu_cc_src);
        tcg_gen_xori_i64(cpu_cc_src, cpu_cc_src, 0x0001);
        s->cc_op = CC_OP_EFLAGS;
        break;
    case 0xf8:
        if (s->cc_op != CC_OP_DYNAMIC)
            gen_op_set_cc_op(s->cc_op);
        gen_compute_eflags(cpu_cc_src);
        tcg_gen_andi_i64(cpu_cc_src, cpu_cc_src, ~0x0001);
        s->cc_op = CC_OP_EFLAGS;
        break;
    case 0xf9:
        if (s->cc_op != CC_OP_DYNAMIC)
            gen_op_set_cc_op(s->cc_op);
        gen_compute_eflags(cpu_cc_src);
        tcg_gen_ori_i64(cpu_cc_src, cpu_cc_src, 0x0001);
        s->cc_op = CC_OP_EFLAGS;
        break;
    case 0xfc:
        tcg_gen_movi_i32(cpu_tmp2_i32, 1);
        tcg_gen_st_i32(cpu_tmp2_i32, cpu_env, __builtin_offsetof (struct CPUX86State, df));
        break;
    case 0xfd:
        tcg_gen_movi_i32(cpu_tmp2_i32, -1);
        tcg_gen_st_i32(cpu_tmp2_i32, cpu_env, __builtin_offsetof (struct CPUX86State, df));
        break;



    case 0x1ba:
        ot = dflag + OT_WORD;
        modrm = ldub_code(s->pc++);
        op = (modrm >> 3) & 7;
        mod = (modrm >> 6) & 3;
        rm = (modrm & 7) | ((s)->rex_b);
        if (mod != 3) {
            s->rip_offset = 1;
            gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
            gen_op_ld_T0_A0(ot + s->mem_index);
        } else {
            gen_op_mov_TN_reg(ot, 0, rm);
        }

        val = ldub_code(s->pc++);
        gen_op_movl_T1_im(val);
        if (op < 4)
            goto illegal_op;
        op -= 4;
        goto bt_op;
    case 0x1a3:
        op = 0;
        goto do_btx;
    case 0x1ab:
        op = 1;
        goto do_btx;
    case 0x1b3:
        op = 2;
        goto do_btx;
    case 0x1bb:
        op = 3;
    do_btx:
        ot = dflag + OT_WORD;
        modrm = ldub_code(s->pc++);
        reg = ((modrm >> 3) & 7) | rex_r;
        mod = (modrm >> 6) & 3;
        rm = (modrm & 7) | ((s)->rex_b);
        gen_op_mov_TN_reg(OT_LONG, 1, reg);
        if (mod != 3) {
            gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);

            gen_exts(ot, cpu_T[1]);
            tcg_gen_sari_i64(cpu_tmp0, cpu_T[1], 3 + ot);
            tcg_gen_shli_i64(cpu_tmp0, cpu_tmp0, ot);
            tcg_gen_add_i64(cpu_A0, cpu_A0, cpu_tmp0);
            gen_op_ld_T0_A0(ot + s->mem_index);
        } else {
            gen_op_mov_TN_reg(ot, 0, rm);
        }
    bt_op:
        tcg_gen_andi_i64(cpu_T[1], cpu_T[1], (1 << (3 + ot)) - 1);
        switch(op) {
        case 0:
            tcg_gen_shr_i64(cpu_cc_src, cpu_T[0], cpu_T[1]);
            tcg_gen_movi_i64(cpu_cc_dst, 0);
            break;
        case 1:
            tcg_gen_shr_i64(cpu_tmp4, cpu_T[0], cpu_T[1]);
            tcg_gen_movi_i64(cpu_tmp0, 1);
            tcg_gen_shl_i64(cpu_tmp0, cpu_tmp0, cpu_T[1]);
            tcg_gen_or_i64(cpu_T[0], cpu_T[0], cpu_tmp0);
            break;
        case 2:
            tcg_gen_shr_i64(cpu_tmp4, cpu_T[0], cpu_T[1]);
            tcg_gen_movi_i64(cpu_tmp0, 1);
            tcg_gen_shl_i64(cpu_tmp0, cpu_tmp0, cpu_T[1]);
            tcg_gen_not_i64(cpu_tmp0, cpu_tmp0);
            tcg_gen_and_i64(cpu_T[0], cpu_T[0], cpu_tmp0);
            break;
        default:
        case 3:
            tcg_gen_shr_i64(cpu_tmp4, cpu_T[0], cpu_T[1]);
            tcg_gen_movi_i64(cpu_tmp0, 1);
            tcg_gen_shl_i64(cpu_tmp0, cpu_tmp0, cpu_T[1]);
            tcg_gen_xor_i64(cpu_T[0], cpu_T[0], cpu_tmp0);
            break;
        }
        s->cc_op = CC_OP_SARB + ot;
        if (op != 0) {
            if (mod != 3)
                gen_op_st_T0_A0(ot + s->mem_index);
            else
                gen_op_mov_reg_T0(ot, rm);
            tcg_gen_mov_i64(cpu_cc_src, cpu_tmp4);
            tcg_gen_movi_i64(cpu_cc_dst, 0);
        }
        break;
    case 0x1bc:
    case 0x1bd:
        {
            int label1;
            TCGv_i64 t0;

            ot = dflag + OT_WORD;
            modrm = ldub_code(s->pc++);
            reg = ((modrm >> 3) & 7) | rex_r;
            gen_ldst_modrm(s,modrm, ot, OR_TMP0, 0);
            gen_extu(ot, cpu_T[0]);
            t0 = tcg_temp_local_new_i64();
            tcg_gen_mov_i64(t0, cpu_T[0]);
            if ((b & 1) && (prefixes & 0x01) &&
                (s->cpuid_ext3_features & (1 << 5))) {
                switch(ot) {
                case OT_WORD: gen_helper_lzcnt(cpu_T[0], t0,
                    tcg_const_i32(16)); break;
                case OT_LONG: gen_helper_lzcnt(cpu_T[0], t0,
                    tcg_const_i32(32)); break;
                case OT_QUAD: gen_helper_lzcnt(cpu_T[0], t0,
                    tcg_const_i32(64)); break;
                }
                gen_op_mov_reg_T0(ot, reg);
            } else {
                label1 = gen_new_label();
                tcg_gen_movi_i64(cpu_cc_dst, 0);
                tcg_gen_brcondi_i64(TCG_COND_EQ, t0, 0, label1);
                if (b & 1) {
                    gen_helper_bsr(cpu_T[0], t0);
                } else {
                    gen_helper_bsf(cpu_T[0], t0);
                }
                gen_op_mov_reg_T0(ot, reg);
                tcg_gen_movi_i64(cpu_cc_dst, 1);
                gen_set_label(label1);
                tcg_gen_discard_i64(cpu_cc_src);
                s->cc_op = CC_OP_LOGICB + ot;
            }
            tcg_temp_free_i64(t0);
        }
        break;


    case 0x27:
        if (((s)->code64))
            goto illegal_op;
        if (s->cc_op != CC_OP_DYNAMIC)
            gen_op_set_cc_op(s->cc_op);
        gen_helper_daa();
        s->cc_op = CC_OP_EFLAGS;
        break;
    case 0x2f:
        if (((s)->code64))
            goto illegal_op;
        if (s->cc_op != CC_OP_DYNAMIC)
            gen_op_set_cc_op(s->cc_op);
        gen_helper_das();
        s->cc_op = CC_OP_EFLAGS;
        break;
    case 0x37:
        if (((s)->code64))
            goto illegal_op;
        if (s->cc_op != CC_OP_DYNAMIC)
            gen_op_set_cc_op(s->cc_op);
        gen_helper_aaa();
        s->cc_op = CC_OP_EFLAGS;
        break;
    case 0x3f:
        if (((s)->code64))
            goto illegal_op;
        if (s->cc_op != CC_OP_DYNAMIC)
            gen_op_set_cc_op(s->cc_op);
        gen_helper_aas();
        s->cc_op = CC_OP_EFLAGS;
        break;
    case 0xd4:
        if (((s)->code64))
            goto illegal_op;
        val = ldub_code(s->pc++);
        if (val == 0) {
            gen_exception(s, 0, pc_start - s->cs_base);
        } else {
            gen_helper_aam(tcg_const_i32(val));
            s->cc_op = CC_OP_LOGICB;
        }
        break;
    case 0xd5:
        if (((s)->code64))
            goto illegal_op;
        val = ldub_code(s->pc++);
        gen_helper_aad(tcg_const_i32(val));
        s->cc_op = CC_OP_LOGICB;
        break;


    case 0x90:

        if (prefixes & 0x04) {
            goto illegal_op;
        }

        if (((s)->rex_b)) {
            goto do_xchg_reg_eax;
        }
        if (prefixes & 0x01) {
            gen_svm_check_intercept(s, pc_start, 0x077);
        }
        break;
    case 0x9b:
        if ((s->flags & ((1 << 9) | (1 << 11))) ==
            ((1 << 9) | (1 << 11))) {
            gen_exception(s, 7, pc_start - s->cs_base);
        } else {
            if (s->cc_op != CC_OP_DYNAMIC)
                gen_op_set_cc_op(s->cc_op);
            gen_jmp_im(pc_start - s->cs_base);
            gen_helper_fwait();
        }
        break;
    case 0xcc:
        gen_interrupt(s, 3, pc_start - s->cs_base, s->pc - s->cs_base);
        break;
    case 0xcd:
        val = ldub_code(s->pc++);
        if (s->vm86 && s->iopl != 3) {
            gen_exception(s, 13, pc_start - s->cs_base);
        } else {
            gen_interrupt(s, val, pc_start - s->cs_base, s->pc - s->cs_base);
        }
        break;
    case 0xce:
        if (((s)->code64))
            goto illegal_op;
        if (s->cc_op != CC_OP_DYNAMIC)
            gen_op_set_cc_op(s->cc_op);
        gen_jmp_im(pc_start - s->cs_base);
        gen_helper_into(tcg_const_i32(s->pc - pc_start));
        break;
# 6702 "../../target-i386/translate.c"
    case 0xfa:
        if (!s->vm86) {
            if (s->cpl <= s->iopl) {
                gen_helper_cli();
            } else {
                gen_exception(s, 13, pc_start - s->cs_base);
            }
        } else {
            if (s->iopl == 3) {
                gen_helper_cli();
            } else {
                gen_exception(s, 13, pc_start - s->cs_base);
            }
        }
        break;
    case 0xfb:
        if (!s->vm86) {
            if (s->cpl <= s->iopl) {
            gen_sti:
                gen_helper_sti();



                if (!(s->tb->flags & (1 << 3)))
                    gen_helper_set_inhibit_irq();

                gen_jmp_im(s->pc - s->cs_base);
                gen_eob(s);
            } else {
                gen_exception(s, 13, pc_start - s->cs_base);
            }
        } else {
            if (s->iopl == 3) {
                goto gen_sti;
            } else {
                gen_exception(s, 13, pc_start - s->cs_base);
            }
        }
        break;
    case 0x62:
        if (((s)->code64))
            goto illegal_op;
        ot = dflag ? OT_LONG : OT_WORD;
        modrm = ldub_code(s->pc++);
        reg = (modrm >> 3) & 7;
        mod = (modrm >> 6) & 3;
        if (mod == 3)
            goto illegal_op;
        gen_op_mov_TN_reg(ot, 0, reg);
        gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
        gen_jmp_im(pc_start - s->cs_base);
        tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
        if (ot == OT_WORD)
            gen_helper_boundw(cpu_A0, cpu_tmp2_i32);
        else
            gen_helper_boundl(cpu_A0, cpu_tmp2_i32);
        break;
    case 0x1c8 ... 0x1cf:
        reg = (b & 7) | ((s)->rex_b);

        if (dflag == 2) {
            gen_op_mov_TN_reg(OT_QUAD, 0, reg);
            tcg_gen_bswap64_i64(cpu_T[0], cpu_T[0]);
            gen_op_mov_reg_T0(OT_QUAD, reg);
        } else

        {
            gen_op_mov_TN_reg(OT_LONG, 0, reg);
            tcg_gen_ext32u_i64(cpu_T[0], cpu_T[0]);
            tcg_gen_bswap32_i64(cpu_T[0], cpu_T[0]);
            gen_op_mov_reg_T0(OT_LONG, reg);
        }
        break;
    case 0xd6:
        if (((s)->code64))
            goto illegal_op;
        if (s->cc_op != CC_OP_DYNAMIC)
            gen_op_set_cc_op(s->cc_op);
        gen_compute_eflags_c(cpu_T[0]);
        tcg_gen_neg_i64(cpu_T[0], cpu_T[0]);
        gen_op_mov_reg_T0(OT_BYTE, 0);
        break;
    case 0xe0:
    case 0xe1:
    case 0xe2:
    case 0xe3:
        {
            int l1, l2, l3;

            tval = (int8_t)insn_get(s, OT_BYTE);
            next_eip = s->pc - s->cs_base;
            tval += next_eip;
            if (s->dflag == 0)
                tval &= 0xffff;

            l1 = gen_new_label();
            l2 = gen_new_label();
            l3 = gen_new_label();
            b &= 3;
            switch(b) {
            case 0:
            case 1:
                if (s->cc_op != CC_OP_DYNAMIC)
                    gen_op_set_cc_op(s->cc_op);
                gen_op_add_reg_im(s->aflag, 1, -1);
                gen_op_jz_ecx(s->aflag, l3);
                gen_compute_eflags(cpu_tmp0);
                tcg_gen_andi_i64(cpu_tmp0, cpu_tmp0, 0x0040);
                if (b == 0) {
                    tcg_gen_brcondi_i64(TCG_COND_EQ, cpu_tmp0, 0, l1);
                } else {
                    tcg_gen_brcondi_i64(TCG_COND_NE, cpu_tmp0, 0, l1);
                }
                break;
            case 2:
                gen_op_add_reg_im(s->aflag, 1, -1);
                gen_op_jnz_ecx(s->aflag, l1);
                break;
            default:
            case 3:
                gen_op_jz_ecx(s->aflag, l1);
                break;
            }

            gen_set_label(l3);
            gen_jmp_im(next_eip);
            tcg_gen_br(l2);

            gen_set_label(l1);
            gen_jmp_im(tval);
            gen_set_label(l2);
            gen_eob(s);
        }
        break;
    case 0x130:
    case 0x132:
        if (s->cpl != 0) {
            gen_exception(s, 13, pc_start - s->cs_base);
        } else {
            if (s->cc_op != CC_OP_DYNAMIC)
                gen_op_set_cc_op(s->cc_op);
            gen_jmp_im(pc_start - s->cs_base);
            if (b & 2) {
                gen_helper_rdmsr();
            } else {
                gen_helper_wrmsr();
            }
        }
        break;
    case 0x131:
        if (s->cc_op != CC_OP_DYNAMIC)
            gen_op_set_cc_op(s->cc_op);
        gen_jmp_im(pc_start - s->cs_base);
        if (use_icount)
            gen_io_start();
        gen_helper_rdtsc();
        if (use_icount) {
            gen_io_end();
            gen_jmp(s, s->pc - s->cs_base);
        }
        break;
    case 0x133:
        if (s->cc_op != CC_OP_DYNAMIC)
            gen_op_set_cc_op(s->cc_op);
        gen_jmp_im(pc_start - s->cs_base);
        gen_helper_rdpmc();
        break;
    case 0x134:

        if (((s)->code64) && cpu_single_env->cpuid_vendor1 != 0x756e6547)
            goto illegal_op;
        if (!s->pe) {
            gen_exception(s, 13, pc_start - s->cs_base);
        } else {
            gen_update_cc_op(s);
            gen_jmp_im(pc_start - s->cs_base);
            gen_helper_sysenter();
            gen_eob(s);
        }
        break;
    case 0x135:

        if (((s)->code64) && cpu_single_env->cpuid_vendor1 != 0x756e6547)
            goto illegal_op;
        if (!s->pe) {
            gen_exception(s, 13, pc_start - s->cs_base);
        } else {
            gen_update_cc_op(s);
            gen_jmp_im(pc_start - s->cs_base);
            gen_helper_sysexit(tcg_const_i32(dflag));
            gen_eob(s);
        }
        break;

    case 0x105:

        gen_update_cc_op(s);
        gen_jmp_im(pc_start - s->cs_base);
        gen_helper_syscall(tcg_const_i32(s->pc - pc_start));
        gen_eob(s);
        break;
    case 0x107:
        if (!s->pe) {
            gen_exception(s, 13, pc_start - s->cs_base);
        } else {
            gen_update_cc_op(s);
            gen_jmp_im(pc_start - s->cs_base);
            gen_helper_sysret(tcg_const_i32(s->dflag));

            if (s->lma)
                s->cc_op = CC_OP_EFLAGS;
            gen_eob(s);
        }
        break;

    case 0x1a2:
        if (s->cc_op != CC_OP_DYNAMIC)
            gen_op_set_cc_op(s->cc_op);
        gen_jmp_im(pc_start - s->cs_base);
        gen_helper_cpuid();
        break;
    case 0xf4:
        if (s->cpl != 0) {
            gen_exception(s, 13, pc_start - s->cs_base);
        } else {
            if (s->cc_op != CC_OP_DYNAMIC)
                gen_op_set_cc_op(s->cc_op);
            gen_jmp_im(pc_start - s->cs_base);
            gen_helper_hlt(tcg_const_i32(s->pc - pc_start));
            s->is_jmp = 3;
        }
        break;
    case 0x100:
        modrm = ldub_code(s->pc++);
        mod = (modrm >> 6) & 3;
        op = (modrm >> 3) & 7;
        switch(op) {
        case 0:
            if (!s->pe || s->vm86)
                goto illegal_op;
            gen_svm_check_intercept(s, pc_start, 0x068);
            tcg_gen_ld32u_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, ldt.selector));
            ot = OT_WORD;
            if (mod == 3)
                ot += s->dflag;
            gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
            break;
        case 2:
            if (!s->pe || s->vm86)
                goto illegal_op;
            if (s->cpl != 0) {
                gen_exception(s, 13, pc_start - s->cs_base);
            } else {
                gen_svm_check_intercept(s, pc_start, 0x06c);
                gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
                gen_jmp_im(pc_start - s->cs_base);
                tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
                gen_helper_lldt(cpu_tmp2_i32);
            }
            break;
        case 1:
            if (!s->pe || s->vm86)
                goto illegal_op;
            gen_svm_check_intercept(s, pc_start, 0x069);
            tcg_gen_ld32u_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, tr.selector));
            ot = OT_WORD;
            if (mod == 3)
                ot += s->dflag;
            gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
            break;
        case 3:
            if (!s->pe || s->vm86)
                goto illegal_op;
            if (s->cpl != 0) {
                gen_exception(s, 13, pc_start - s->cs_base);
            } else {
                gen_svm_check_intercept(s, pc_start, 0x06d);
                gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
                gen_jmp_im(pc_start - s->cs_base);
                tcg_gen_trunc_i64_i32(cpu_tmp2_i32, cpu_T[0]);
                gen_helper_ltr(cpu_tmp2_i32);
            }
            break;
        case 4:
        case 5:
            if (!s->pe || s->vm86)
                goto illegal_op;
            gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
            if (s->cc_op != CC_OP_DYNAMIC)
                gen_op_set_cc_op(s->cc_op);
            if (op == 4)
                gen_helper_verr(cpu_T[0]);
            else
                gen_helper_verw(cpu_T[0]);
            s->cc_op = CC_OP_EFLAGS;
            break;
        default:
            goto illegal_op;
        }
        break;
    case 0x101:
        modrm = ldub_code(s->pc++);
        mod = (modrm >> 6) & 3;
        op = (modrm >> 3) & 7;
        rm = modrm & 7;
        switch(op) {
        case 0:
            if (mod == 3)
                goto illegal_op;
            gen_svm_check_intercept(s, pc_start, 0x067);
            gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
            tcg_gen_ld32u_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, gdt.limit));
            gen_op_st_T0_A0(OT_WORD + s->mem_index);
            gen_add_A0_im(s, 2);
            tcg_gen_ld_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, gdt.base));
            if (!s->dflag)
                gen_op_andl_T0_im(0xffffff);
            gen_op_st_T0_A0(((s)->code64) + OT_LONG + s->mem_index);
            break;
        case 1:
            if (mod == 3) {
                switch (rm) {
                case 0:
                    if (!(s->cpuid_ext_features & (1 << 3)) ||
                        s->cpl != 0)
                        goto illegal_op;
                    if (s->cc_op != CC_OP_DYNAMIC)
                        gen_op_set_cc_op(s->cc_op);
                    gen_jmp_im(pc_start - s->cs_base);

                    if (s->aflag == 2) {
                        gen_op_movq_A0_reg(0);
                    } else

                    {
                        gen_op_movl_A0_reg(0);
                        if (s->aflag == 0)
                            gen_op_andl_A0_ffff();
                    }
                    gen_add_A0_ds_seg(s);
                    gen_helper_monitor(cpu_A0);
                    break;
                case 1:
                    if (!(s->cpuid_ext_features & (1 << 3)) ||
                        s->cpl != 0)
                        goto illegal_op;
                    gen_update_cc_op(s);
                    gen_jmp_im(pc_start - s->cs_base);
                    gen_helper_mwait(tcg_const_i32(s->pc - pc_start));
                    gen_eob(s);
                    break;
                default:
                    goto illegal_op;
                }
            } else {
                gen_svm_check_intercept(s, pc_start, 0x066);
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                tcg_gen_ld32u_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, idt.limit));
                gen_op_st_T0_A0(OT_WORD + s->mem_index);
                gen_add_A0_im(s, 2);
                tcg_gen_ld_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, idt.base));
                if (!s->dflag)
                    gen_op_andl_T0_im(0xffffff);
                gen_op_st_T0_A0(((s)->code64) + OT_LONG + s->mem_index);
            }
            break;
        case 2:
        case 3:
            if (mod == 3) {
                if (s->cc_op != CC_OP_DYNAMIC)
                    gen_op_set_cc_op(s->cc_op);
                gen_jmp_im(pc_start - s->cs_base);
                switch(rm) {
                case 0:
                    if (!(s->flags & (1 << 20)) || !s->pe)
                        goto illegal_op;
                    if (s->cpl != 0) {
                        gen_exception(s, 13, pc_start - s->cs_base);
                        break;
                    } else {
                        gen_helper_vmrun(tcg_const_i32(s->aflag),
                                         tcg_const_i32(s->pc - pc_start));
                        tcg_gen_exit_tb(0);
                        s->is_jmp = 3;
                    }
                    break;
                case 1:
                    if (!(s->flags & (1 << 20)))
                        goto illegal_op;
                    gen_helper_vmmcall();
                    break;
                case 2:
                    if (!(s->flags & (1 << 20)) || !s->pe)
                        goto illegal_op;
                    if (s->cpl != 0) {
                        gen_exception(s, 13, pc_start - s->cs_base);
                        break;
                    } else {
                        gen_helper_vmload(tcg_const_i32(s->aflag));
                    }
                    break;
                case 3:
                    if (!(s->flags & (1 << 20)) || !s->pe)
                        goto illegal_op;
                    if (s->cpl != 0) {
                        gen_exception(s, 13, pc_start - s->cs_base);
                        break;
                    } else {
                        gen_helper_vmsave(tcg_const_i32(s->aflag));
                    }
                    break;
                case 4:
                    if ((!(s->flags & (1 << 20)) &&
                         !(s->cpuid_ext3_features & (1 << 12))) ||
                        !s->pe)
                        goto illegal_op;
                    if (s->cpl != 0) {
                        gen_exception(s, 13, pc_start - s->cs_base);
                        break;
                    } else {
                        gen_helper_stgi();
                    }
                    break;
                case 5:
                    if (!(s->flags & (1 << 20)) || !s->pe)
                        goto illegal_op;
                    if (s->cpl != 0) {
                        gen_exception(s, 13, pc_start - s->cs_base);
                        break;
                    } else {
                        gen_helper_clgi();
                    }
                    break;
                case 6:
                    if ((!(s->flags & (1 << 20)) &&
                         !(s->cpuid_ext3_features & (1 << 12))) ||
                        !s->pe)
                        goto illegal_op;
                    gen_helper_skinit();
                    break;
                case 7:
                    if (!(s->flags & (1 << 20)) || !s->pe)
                        goto illegal_op;
                    if (s->cpl != 0) {
                        gen_exception(s, 13, pc_start - s->cs_base);
                        break;
                    } else {
                        gen_helper_invlpga(tcg_const_i32(s->aflag));
                    }
                    break;
                default:
                    goto illegal_op;
                }
            } else if (s->cpl != 0) {
                gen_exception(s, 13, pc_start - s->cs_base);
            } else {
                gen_svm_check_intercept(s, pc_start,
                                        op==2 ? 0x06b : 0x06a);
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                gen_op_ld_T1_A0(OT_WORD + s->mem_index);
                gen_add_A0_im(s, 2);
                gen_op_ld_T0_A0(((s)->code64) + OT_LONG + s->mem_index);
                if (!s->dflag)
                    gen_op_andl_T0_im(0xffffff);
                if (op == 2) {
                    tcg_gen_st_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, gdt.base));
                    tcg_gen_st32_i64(cpu_T[1], cpu_env, __builtin_offsetof (CPUX86State, gdt.limit));
                } else {
                    tcg_gen_st_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, idt.base));
                    tcg_gen_st32_i64(cpu_T[1], cpu_env, __builtin_offsetof (CPUX86State, idt.limit));
                }
            }
            break;
        case 4:
            gen_svm_check_intercept(s, pc_start, 0x000);



            tcg_gen_ld32u_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, cr[0]));

            gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 1);
            break;
        case 6:
            if (s->cpl != 0) {
                gen_exception(s, 13, pc_start - s->cs_base);
            } else {
                gen_svm_check_intercept(s, pc_start, 0x010);
                gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
                gen_helper_lmsw(cpu_T[0]);
                gen_jmp_im(s->pc - s->cs_base);
                gen_eob(s);
            }
            break;
        case 7:
            if (mod != 3) {
                if (s->cpl != 0) {
                    gen_exception(s, 13, pc_start - s->cs_base);
                } else {
                    if (s->cc_op != CC_OP_DYNAMIC)
                        gen_op_set_cc_op(s->cc_op);
                    gen_jmp_im(pc_start - s->cs_base);
                    gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                    gen_helper_invlpg(cpu_A0);
                    gen_jmp_im(s->pc - s->cs_base);
                    gen_eob(s);
                }
            } else {
                switch (rm) {
                case 0:

                    if (((s)->code64)) {
                        if (s->cpl != 0) {
                            gen_exception(s, 13, pc_start - s->cs_base);
                        } else {
                            tcg_gen_ld_i64(cpu_T[0], cpu_env,
                                __builtin_offsetof (CPUX86State, segs[5].base));
                            tcg_gen_ld_i64(cpu_T[1], cpu_env,
                                __builtin_offsetof (CPUX86State, kernelgsbase));
                            tcg_gen_st_i64(cpu_T[1], cpu_env,
                                __builtin_offsetof (CPUX86State, segs[5].base));
                            tcg_gen_st_i64(cpu_T[0], cpu_env,
                                __builtin_offsetof (CPUX86State, kernelgsbase));
                        }
                    } else

                    {
                        goto illegal_op;
                    }
                    break;
                case 1:
                    if (!(s->cpuid_ext2_features & (1 << 27)))
                        goto illegal_op;
                    if (s->cc_op != CC_OP_DYNAMIC)
                        gen_op_set_cc_op(s->cc_op);
                    gen_jmp_im(pc_start - s->cs_base);
                    if (use_icount)
                        gen_io_start();
                    gen_helper_rdtscp();
                    if (use_icount) {
                        gen_io_end();
                        gen_jmp(s, s->pc - s->cs_base);
                    }
                    break;
                default:
                    goto illegal_op;
                }
            }
            break;
        default:
            goto illegal_op;
        }
        break;
    case 0x108:
    case 0x109:
        if (s->cpl != 0) {
            gen_exception(s, 13, pc_start - s->cs_base);
        } else {
            gen_svm_check_intercept(s, pc_start, (b & 2) ? 0x076 : 0x089);

        }
        break;
    case 0x63:

        if (((s)->code64)) {
            int d_ot;

            d_ot = dflag + OT_WORD;

            modrm = ldub_code(s->pc++);
            reg = ((modrm >> 3) & 7) | rex_r;
            mod = (modrm >> 6) & 3;
            rm = (modrm & 7) | ((s)->rex_b);

            if (mod == 3) {
                gen_op_mov_TN_reg(OT_LONG, 0, rm);

                if (d_ot == OT_QUAD)
                    tcg_gen_ext32s_i64(cpu_T[0], cpu_T[0]);
                gen_op_mov_reg_T0(d_ot, reg);
            } else {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                if (d_ot == OT_QUAD) {
                    gen_op_lds_T0_A0(OT_LONG + s->mem_index);
                } else {
                    gen_op_ld_T0_A0(OT_LONG + s->mem_index);
                }
                gen_op_mov_reg_T0(d_ot, reg);
            }
        } else

        {
            int label1;
            TCGv_i64 t0, t1, t2, a0;

            if (!s->pe || s->vm86)
                goto illegal_op;
            t0 = tcg_temp_local_new_i64();
            t1 = tcg_temp_local_new_i64();
            t2 = tcg_temp_local_new_i64();
            ot = OT_WORD;
            modrm = ldub_code(s->pc++);
            reg = (modrm >> 3) & 7;
            mod = (modrm >> 6) & 3;
            rm = modrm & 7;
            if (mod != 3) {
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
                gen_op_ld_v(ot + s->mem_index, t0, cpu_A0);
                a0 = tcg_temp_local_new_i64();
                tcg_gen_mov_i64(a0, cpu_A0);
            } else {
                gen_op_mov_v_reg(ot, t0, rm);
                a0 = (-1);
            }
            gen_op_mov_v_reg(ot, t1, reg);
            tcg_gen_andi_i64(cpu_tmp0, t0, 3);
            tcg_gen_andi_i64(t1, t1, 3);
            tcg_gen_movi_i64(t2, 0);
            label1 = gen_new_label();
            tcg_gen_brcond_i64(TCG_COND_GE, cpu_tmp0, t1, label1);
            tcg_gen_andi_i64(t0, t0, ~3);
            tcg_gen_or_i64(t0, t0, t1);
            tcg_gen_movi_i64(t2, 0x0040);
            gen_set_label(label1);
            if (mod != 3) {
                gen_op_st_v(ot + s->mem_index, t0, a0);
                tcg_temp_free_i64(a0);
           } else {
                gen_op_mov_reg_v(ot, rm, t0);
            }
            if (s->cc_op != CC_OP_DYNAMIC)
                gen_op_set_cc_op(s->cc_op);
            gen_compute_eflags(cpu_cc_src);
            tcg_gen_andi_i64(cpu_cc_src, cpu_cc_src, ~0x0040);
            tcg_gen_or_i64(cpu_cc_src, cpu_cc_src, t2);
            s->cc_op = CC_OP_EFLAGS;
            tcg_temp_free_i64(t0);
            tcg_temp_free_i64(t1);
            tcg_temp_free_i64(t2);
        }
        break;
    case 0x102:
    case 0x103:
        {
            int label1;
            TCGv_i64 t0;
            if (!s->pe || s->vm86)
                goto illegal_op;
            ot = dflag ? OT_LONG : OT_WORD;
            modrm = ldub_code(s->pc++);
            reg = ((modrm >> 3) & 7) | rex_r;
            gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
            t0 = tcg_temp_local_new_i64();
            if (s->cc_op != CC_OP_DYNAMIC)
                gen_op_set_cc_op(s->cc_op);
            if (b == 0x102)
                gen_helper_lar(t0, cpu_T[0]);
            else
                gen_helper_lsl(t0, cpu_T[0]);
            tcg_gen_andi_i64(cpu_tmp0, cpu_cc_src, 0x0040);
            label1 = gen_new_label();
            tcg_gen_brcondi_i64(TCG_COND_EQ, cpu_tmp0, 0, label1);
            gen_op_mov_reg_v(ot, reg, t0);
            gen_set_label(label1);
            s->cc_op = CC_OP_EFLAGS;
            tcg_temp_free_i64(t0);
        }
        break;
    case 0x118:
        modrm = ldub_code(s->pc++);
        mod = (modrm >> 6) & 3;
        op = (modrm >> 3) & 7;
        switch(op) {
        case 0:
        case 1:
        case 2:
        case 3:
            if (mod == 3)
                goto illegal_op;
            gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);

            break;
        default:
            gen_nop_modrm(s, modrm);
            break;
        }
        break;
    case 0x119 ... 0x11f:
        modrm = ldub_code(s->pc++);
        gen_nop_modrm(s, modrm);
        break;
    case 0x120:
    case 0x122:
        if (s->cpl != 0) {
            gen_exception(s, 13, pc_start - s->cs_base);
        } else {
            modrm = ldub_code(s->pc++);
            if ((modrm & 0xc0) != 0xc0)
                goto illegal_op;
            rm = (modrm & 7) | ((s)->rex_b);
            reg = ((modrm >> 3) & 7) | rex_r;
            if (((s)->code64))
                ot = OT_QUAD;
            else
                ot = OT_LONG;
            if ((prefixes & 0x04) && (reg == 0) &&
                (s->cpuid_ext3_features & (1 << 4))) {
                reg = 8;
            }
            switch(reg) {
            case 0:
            case 2:
            case 3:
            case 4:
            case 8:
                if (s->cc_op != CC_OP_DYNAMIC)
                    gen_op_set_cc_op(s->cc_op);
                gen_jmp_im(pc_start - s->cs_base);
                if (b & 2) {
                    gen_op_mov_TN_reg(ot, 0, rm);
                    gen_helper_write_crN(tcg_const_i32(reg), cpu_T[0]);
                    gen_jmp_im(s->pc - s->cs_base);
                    gen_eob(s);
                } else {
                    gen_helper_read_crN(cpu_T[0], tcg_const_i32(reg));
                    gen_op_mov_reg_T0(ot, rm);
                }
                break;
            default:
                goto illegal_op;
            }
        }
        break;
    case 0x121:
    case 0x123:
        if (s->cpl != 0) {
            gen_exception(s, 13, pc_start - s->cs_base);
        } else {
            modrm = ldub_code(s->pc++);
            if ((modrm & 0xc0) != 0xc0)
                goto illegal_op;
            rm = (modrm & 7) | ((s)->rex_b);
            reg = ((modrm >> 3) & 7) | rex_r;
            if (((s)->code64))
                ot = OT_QUAD;
            else
                ot = OT_LONG;

            if (reg == 4 || reg == 5 || reg >= 8)
                goto illegal_op;
            if (b & 2) {
                gen_svm_check_intercept(s, pc_start, 0x030 + reg);
                gen_op_mov_TN_reg(ot, 0, rm);
                gen_helper_movl_drN_T0(tcg_const_i32(reg), cpu_T[0]);
                gen_jmp_im(s->pc - s->cs_base);
                gen_eob(s);
            } else {
                gen_svm_check_intercept(s, pc_start, 0x020 + reg);
                tcg_gen_ld_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, dr[reg]));
                gen_op_mov_reg_T0(ot, rm);
            }
        }
        break;
    case 0x106:
        if (s->cpl != 0) {
            gen_exception(s, 13, pc_start - s->cs_base);
        } else {
            gen_svm_check_intercept(s, pc_start, 0x010);
            gen_helper_clts();

            gen_jmp_im(s->pc - s->cs_base);
            gen_eob(s);
        }
        break;

    case 0x1c3:
        if (!(s->cpuid_features & (1 << 26)))
            goto illegal_op;
        ot = s->dflag == 2 ? OT_QUAD : OT_LONG;
        modrm = ldub_code(s->pc++);
        mod = (modrm >> 6) & 3;
        if (mod == 3)
            goto illegal_op;
        reg = ((modrm >> 3) & 7) | rex_r;

        gen_ldst_modrm(s, modrm, ot, reg, 1);
        break;
    case 0x1ae:
        modrm = ldub_code(s->pc++);
        mod = (modrm >> 6) & 3;
        op = (modrm >> 3) & 7;
        switch(op) {
        case 0:
            if (mod == 3 || !(s->cpuid_features & (1 << 24)) ||
                (s->prefix & 0x04))
                goto illegal_op;
            if ((s->flags & (1 << 10)) || (s->flags & (1 << 11))) {
                gen_exception(s, 7, pc_start - s->cs_base);
                break;
            }
            gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
            if (s->cc_op != CC_OP_DYNAMIC)
                gen_op_set_cc_op(s->cc_op);
            gen_jmp_im(pc_start - s->cs_base);
            gen_helper_fxsave(cpu_A0, tcg_const_i32((s->dflag == 2)));
            break;
        case 1:
            if (mod == 3 || !(s->cpuid_features & (1 << 24)) ||
                (s->prefix & 0x04))
                goto illegal_op;
            if ((s->flags & (1 << 10)) || (s->flags & (1 << 11))) {
                gen_exception(s, 7, pc_start - s->cs_base);
                break;
            }
            gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
            if (s->cc_op != CC_OP_DYNAMIC)
                gen_op_set_cc_op(s->cc_op);
            gen_jmp_im(pc_start - s->cs_base);
            gen_helper_fxrstor(cpu_A0, tcg_const_i32((s->dflag == 2)));
            break;
        case 2:
        case 3:
            if (s->flags & (1 << 11)) {
                gen_exception(s, 7, pc_start - s->cs_base);
                break;
            }
            if ((s->flags & (1 << 10)) || !(s->flags & (1 << 22)) ||
                mod == 3)
                goto illegal_op;
            gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
            if (op == 2) {
                gen_op_ld_T0_A0(OT_LONG + s->mem_index);
                tcg_gen_st32_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, mxcsr));
            } else {
                tcg_gen_ld32u_i64(cpu_T[0], cpu_env, __builtin_offsetof (CPUX86State, mxcsr));
                gen_op_st_T0_A0(OT_LONG + s->mem_index);
            }
            break;
        case 5:
        case 6:
            if ((modrm & 0xc7) != 0xc0 || !(s->cpuid_features & (1 << 25)))
                goto illegal_op;
            break;
        case 7:
            if ((modrm & 0xc7) == 0xc0) {


                if (!(s->cpuid_features & (1 << 25)))
                    goto illegal_op;
            } else {

                if (!(s->cpuid_features & (1 << 19)))
                    goto illegal_op;
                gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
            }
            break;
        default:
            goto illegal_op;
        }
        break;
    case 0x10d:
        modrm = ldub_code(s->pc++);
        mod = (modrm >> 6) & 3;
        if (mod == 3)
            goto illegal_op;
        gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);

        break;
    case 0x1aa:
        gen_svm_check_intercept(s, pc_start, 0x073);
        if (!(s->flags & (1 << 19)))
            goto illegal_op;
        gen_update_cc_op(s);
        gen_jmp_im(s->pc - s->cs_base);
        gen_helper_rsm();
        gen_eob(s);
        break;
    case 0x1b8:
        if ((prefixes & (0x01 | 0x04 | 0x02)) !=
             0x01)
            goto illegal_op;
        if (!(s->cpuid_ext_features & (1 << 23)))
            goto illegal_op;

        modrm = ldub_code(s->pc++);
        reg = ((modrm >> 3) & 7);

        if (s->prefix & 0x08)
            ot = OT_WORD;
        else if (s->dflag != 2)
            ot = OT_LONG;
        else
            ot = OT_QUAD;

        gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
        gen_helper_popcnt(cpu_T[0], cpu_T[0], tcg_const_i32(ot));
        gen_op_mov_reg_T0(ot, reg);

        s->cc_op = CC_OP_EFLAGS;
        break;
    case 0x10e ... 0x10f:

        s->prefix &= ~(0x01 | 0x02 | 0x08);
    case 0x110 ... 0x117:
    case 0x128 ... 0x12f:
    case 0x138 ... 0x13a:
    case 0x150 ... 0x179:
    case 0x17c ... 0x17f:
    case 0x1c2:
    case 0x1c4 ... 0x1c6:
    case 0x1d0 ... 0x1fe:
        gen_sse(s, b, pc_start, rex_r);
        break;
    default:
        goto illegal_op;
    }

    if (s->prefix & 0x04)
        gen_helper_unlock();
    return s->pc;
 illegal_op:
    if (s->prefix & 0x04)
        gen_helper_unlock();

    gen_exception(s, 6, pc_start - s->cs_base);
    return s->pc;
}

void optimize_flags_init(void)
{

    ((sizeof(CCTable) == (1 << 3)) ? (void) (0) : __assert_fail ("sizeof(CCTable) == (1 << 3)", "../../target-i386/translate.c", 7632, __PRETTY_FUNCTION__));



    cpu_env = tcg_global_reg_new_i32(TCG_AREG0, "env");
    cpu_cc_op = tcg_global_mem_new_i32(TCG_AREG0,
                                       __builtin_offsetof (struct CPUX86State, cc_op), "cc_op");
    cpu_cc_src = tcg_global_mem_new_i64(TCG_AREG0, __builtin_offsetof (struct CPUX86State, cc_src),
                                    "cc_src");
    cpu_cc_dst = tcg_global_mem_new_i64(TCG_AREG0, __builtin_offsetof (struct CPUX86State, cc_dst),
                                    "cc_dst");
    cpu_cc_tmp = tcg_global_mem_new_i64(TCG_AREG0, __builtin_offsetof (struct CPUX86State, cc_tmp),
                                    "cc_tmp");


    cpu_regs[0] = tcg_global_mem_new_i64(TCG_AREG0,
                                             __builtin_offsetof (struct CPUX86State, regs[0]), "rax");
    cpu_regs[1] = tcg_global_mem_new_i64(TCG_AREG0,
                                             __builtin_offsetof (struct CPUX86State, regs[1]), "rcx");
    cpu_regs[2] = tcg_global_mem_new_i64(TCG_AREG0,
                                             __builtin_offsetof (struct CPUX86State, regs[2]), "rdx");
    cpu_regs[3] = tcg_global_mem_new_i64(TCG_AREG0,
                                             __builtin_offsetof (struct CPUX86State, regs[3]), "rbx");
    cpu_regs[4] = tcg_global_mem_new_i64(TCG_AREG0,
                                             __builtin_offsetof (struct CPUX86State, regs[4]), "rsp");
    cpu_regs[5] = tcg_global_mem_new_i64(TCG_AREG0,
                                             __builtin_offsetof (struct CPUX86State, regs[5]), "rbp");
    cpu_regs[6] = tcg_global_mem_new_i64(TCG_AREG0,
                                             __builtin_offsetof (struct CPUX86State, regs[6]), "rsi");
    cpu_regs[7] = tcg_global_mem_new_i64(TCG_AREG0,
                                             __builtin_offsetof (struct CPUX86State, regs[7]), "rdi");
    cpu_regs[8] = tcg_global_mem_new_i64(TCG_AREG0,
                                         __builtin_offsetof (struct CPUX86State, regs[8]), "r8");
    cpu_regs[9] = tcg_global_mem_new_i64(TCG_AREG0,
                                          __builtin_offsetof (struct CPUX86State, regs[9]), "r9");
    cpu_regs[10] = tcg_global_mem_new_i64(TCG_AREG0,
                                          __builtin_offsetof (struct CPUX86State, regs[10]), "r10");
    cpu_regs[11] = tcg_global_mem_new_i64(TCG_AREG0,
                                          __builtin_offsetof (struct CPUX86State, regs[11]), "r11");
    cpu_regs[12] = tcg_global_mem_new_i64(TCG_AREG0,
                                          __builtin_offsetof (struct CPUX86State, regs[12]), "r12");
    cpu_regs[13] = tcg_global_mem_new_i64(TCG_AREG0,
                                          __builtin_offsetof (struct CPUX86State, regs[13]), "r13");
    cpu_regs[14] = tcg_global_mem_new_i64(TCG_AREG0,
                                          __builtin_offsetof (struct CPUX86State, regs[14]), "r14");
    cpu_regs[15] = tcg_global_mem_new_i64(TCG_AREG0,
                                          __builtin_offsetof (struct CPUX86State, regs[15]), "r15");
# 7700 "../../target-i386/translate.c"
# 1 "../../target-i386/helper.h" 1
# 1 "../../def-helper.h" 1
# 2 "../../target-i386/helper.h" 2

tcg_register_helper(helper_cc_compute_all, "cc_compute_all");
tcg_register_helper(helper_cc_compute_c, "cc_compute_c");

tcg_register_helper(helper_lock, "lock");
tcg_register_helper(helper_unlock, "unlock");
tcg_register_helper(helper_write_eflags, "write_eflags");
tcg_register_helper(helper_read_eflags, "read_eflags");
tcg_register_helper(helper_divb_AL, "divb_AL");
tcg_register_helper(helper_idivb_AL, "idivb_AL");
tcg_register_helper(helper_divw_AX, "divw_AX");
tcg_register_helper(helper_idivw_AX, "idivw_AX");
tcg_register_helper(helper_divl_EAX, "divl_EAX");
tcg_register_helper(helper_idivl_EAX, "idivl_EAX");

tcg_register_helper(helper_mulq_EAX_T0, "mulq_EAX_T0");
tcg_register_helper(helper_imulq_EAX_T0, "imulq_EAX_T0");
tcg_register_helper(helper_imulq_T0_T1, "imulq_T0_T1");
tcg_register_helper(helper_divq_EAX, "divq_EAX");
tcg_register_helper(helper_idivq_EAX, "idivq_EAX");


tcg_register_helper(helper_aam, "aam");
tcg_register_helper(helper_aad, "aad");
tcg_register_helper(helper_aaa, "aaa");
tcg_register_helper(helper_aas, "aas");
tcg_register_helper(helper_daa, "daa");
tcg_register_helper(helper_das, "das");

tcg_register_helper(helper_lsl, "lsl");
tcg_register_helper(helper_lar, "lar");
tcg_register_helper(helper_verr, "verr");
tcg_register_helper(helper_verw, "verw");
tcg_register_helper(helper_lldt, "lldt");
tcg_register_helper(helper_ltr, "ltr");
tcg_register_helper(helper_load_seg, "load_seg");
tcg_register_helper(helper_ljmp_protected, "ljmp_protected");
tcg_register_helper(helper_lcall_real, "lcall_real");
tcg_register_helper(helper_lcall_protected, "lcall_protected");
tcg_register_helper(helper_iret_real, "iret_real");
tcg_register_helper(helper_iret_protected, "iret_protected");
tcg_register_helper(helper_lret_protected, "lret_protected");
tcg_register_helper(helper_read_crN, "read_crN");
tcg_register_helper(helper_write_crN, "write_crN");
tcg_register_helper(helper_lmsw, "lmsw");
tcg_register_helper(helper_clts, "clts");
tcg_register_helper(helper_movl_drN_T0, "movl_drN_T0");
tcg_register_helper(helper_invlpg, "invlpg");

tcg_register_helper(helper_enter_level, "enter_level");

tcg_register_helper(helper_enter64_level, "enter64_level");

tcg_register_helper(helper_sysenter, "sysenter");
tcg_register_helper(helper_sysexit, "sysexit");

tcg_register_helper(helper_syscall, "syscall");
tcg_register_helper(helper_sysret, "sysret");

tcg_register_helper(helper_hlt, "hlt");
tcg_register_helper(helper_monitor, "monitor");
tcg_register_helper(helper_mwait, "mwait");
tcg_register_helper(helper_debug, "debug");
tcg_register_helper(helper_reset_rf, "reset_rf");
tcg_register_helper(helper_raise_interrupt, "raise_interrupt");
tcg_register_helper(helper_raise_exception, "raise_exception");
tcg_register_helper(helper_cli, "cli");
tcg_register_helper(helper_sti, "sti");
tcg_register_helper(helper_set_inhibit_irq, "set_inhibit_irq");
tcg_register_helper(helper_reset_inhibit_irq, "reset_inhibit_irq");
tcg_register_helper(helper_boundw, "boundw");
tcg_register_helper(helper_boundl, "boundl");
tcg_register_helper(helper_rsm, "rsm");
tcg_register_helper(helper_into, "into");
tcg_register_helper(helper_cmpxchg8b, "cmpxchg8b");

tcg_register_helper(helper_cmpxchg16b, "cmpxchg16b");

tcg_register_helper(helper_single_step, "single_step");
tcg_register_helper(helper_cpuid, "cpuid");
tcg_register_helper(helper_rdtsc, "rdtsc");
tcg_register_helper(helper_rdtscp, "rdtscp");
tcg_register_helper(helper_rdpmc, "rdpmc");
tcg_register_helper(helper_rdmsr, "rdmsr");
tcg_register_helper(helper_wrmsr, "wrmsr");

tcg_register_helper(helper_check_iob, "check_iob");
tcg_register_helper(helper_check_iow, "check_iow");
tcg_register_helper(helper_check_iol, "check_iol");
tcg_register_helper(helper_outb, "outb");
tcg_register_helper(helper_inb, "inb");
tcg_register_helper(helper_outw, "outw");
tcg_register_helper(helper_inw, "inw");
tcg_register_helper(helper_outl, "outl");
tcg_register_helper(helper_inl, "inl");

tcg_register_helper(helper_svm_check_intercept_param, "svm_check_intercept_param");
tcg_register_helper(helper_vmexit, "vmexit");
tcg_register_helper(helper_svm_check_io, "svm_check_io");
tcg_register_helper(helper_vmrun, "vmrun");
tcg_register_helper(helper_vmmcall, "vmmcall");
tcg_register_helper(helper_vmload, "vmload");
tcg_register_helper(helper_vmsave, "vmsave");
tcg_register_helper(helper_stgi, "stgi");
tcg_register_helper(helper_clgi, "clgi");
tcg_register_helper(helper_skinit, "skinit");
tcg_register_helper(helper_invlpga, "invlpga");



tcg_register_helper(helper_flds_FT0, "flds_FT0");
tcg_register_helper(helper_fldl_FT0, "fldl_FT0");
tcg_register_helper(helper_fildl_FT0, "fildl_FT0");
tcg_register_helper(helper_flds_ST0, "flds_ST0");
tcg_register_helper(helper_fldl_ST0, "fldl_ST0");
tcg_register_helper(helper_fildl_ST0, "fildl_ST0");
tcg_register_helper(helper_fildll_ST0, "fildll_ST0");
tcg_register_helper(helper_fsts_ST0, "fsts_ST0");
tcg_register_helper(helper_fstl_ST0, "fstl_ST0");
tcg_register_helper(helper_fist_ST0, "fist_ST0");
tcg_register_helper(helper_fistl_ST0, "fistl_ST0");
tcg_register_helper(helper_fistll_ST0, "fistll_ST0");
tcg_register_helper(helper_fistt_ST0, "fistt_ST0");
tcg_register_helper(helper_fisttl_ST0, "fisttl_ST0");
tcg_register_helper(helper_fisttll_ST0, "fisttll_ST0");
tcg_register_helper(helper_fldt_ST0, "fldt_ST0");
tcg_register_helper(helper_fstt_ST0, "fstt_ST0");
tcg_register_helper(helper_fpush, "fpush");
tcg_register_helper(helper_fpop, "fpop");
tcg_register_helper(helper_fdecstp, "fdecstp");
tcg_register_helper(helper_fincstp, "fincstp");
tcg_register_helper(helper_ffree_STN, "ffree_STN");
tcg_register_helper(helper_fmov_ST0_FT0, "fmov_ST0_FT0");
tcg_register_helper(helper_fmov_FT0_STN, "fmov_FT0_STN");
tcg_register_helper(helper_fmov_ST0_STN, "fmov_ST0_STN");
tcg_register_helper(helper_fmov_STN_ST0, "fmov_STN_ST0");
tcg_register_helper(helper_fxchg_ST0_STN, "fxchg_ST0_STN");
tcg_register_helper(helper_fcom_ST0_FT0, "fcom_ST0_FT0");
tcg_register_helper(helper_fucom_ST0_FT0, "fucom_ST0_FT0");
tcg_register_helper(helper_fcomi_ST0_FT0, "fcomi_ST0_FT0");
tcg_register_helper(helper_fucomi_ST0_FT0, "fucomi_ST0_FT0");
tcg_register_helper(helper_fadd_ST0_FT0, "fadd_ST0_FT0");
tcg_register_helper(helper_fmul_ST0_FT0, "fmul_ST0_FT0");
tcg_register_helper(helper_fsub_ST0_FT0, "fsub_ST0_FT0");
tcg_register_helper(helper_fsubr_ST0_FT0, "fsubr_ST0_FT0");
tcg_register_helper(helper_fdiv_ST0_FT0, "fdiv_ST0_FT0");
tcg_register_helper(helper_fdivr_ST0_FT0, "fdivr_ST0_FT0");
tcg_register_helper(helper_fadd_STN_ST0, "fadd_STN_ST0");
tcg_register_helper(helper_fmul_STN_ST0, "fmul_STN_ST0");
tcg_register_helper(helper_fsub_STN_ST0, "fsub_STN_ST0");
tcg_register_helper(helper_fsubr_STN_ST0, "fsubr_STN_ST0");
tcg_register_helper(helper_fdiv_STN_ST0, "fdiv_STN_ST0");
tcg_register_helper(helper_fdivr_STN_ST0, "fdivr_STN_ST0");
tcg_register_helper(helper_fchs_ST0, "fchs_ST0");
tcg_register_helper(helper_fabs_ST0, "fabs_ST0");
tcg_register_helper(helper_fxam_ST0, "fxam_ST0");
tcg_register_helper(helper_fld1_ST0, "fld1_ST0");
tcg_register_helper(helper_fldl2t_ST0, "fldl2t_ST0");
tcg_register_helper(helper_fldl2e_ST0, "fldl2e_ST0");
tcg_register_helper(helper_fldpi_ST0, "fldpi_ST0");
tcg_register_helper(helper_fldlg2_ST0, "fldlg2_ST0");
tcg_register_helper(helper_fldln2_ST0, "fldln2_ST0");
tcg_register_helper(helper_fldz_ST0, "fldz_ST0");
tcg_register_helper(helper_fldz_FT0, "fldz_FT0");
tcg_register_helper(helper_fnstsw, "fnstsw");
tcg_register_helper(helper_fnstcw, "fnstcw");
tcg_register_helper(helper_fldcw, "fldcw");
tcg_register_helper(helper_fclex, "fclex");
tcg_register_helper(helper_fwait, "fwait");
tcg_register_helper(helper_fninit, "fninit");
tcg_register_helper(helper_fbld_ST0, "fbld_ST0");
tcg_register_helper(helper_fbst_ST0, "fbst_ST0");
tcg_register_helper(helper_f2xm1, "f2xm1");
tcg_register_helper(helper_fyl2x, "fyl2x");
tcg_register_helper(helper_fptan, "fptan");
tcg_register_helper(helper_fpatan, "fpatan");
tcg_register_helper(helper_fxtract, "fxtract");
tcg_register_helper(helper_fprem1, "fprem1");
tcg_register_helper(helper_fprem, "fprem");
tcg_register_helper(helper_fyl2xp1, "fyl2xp1");
tcg_register_helper(helper_fsqrt, "fsqrt");
tcg_register_helper(helper_fsincos, "fsincos");
tcg_register_helper(helper_frndint, "frndint");
tcg_register_helper(helper_fscale, "fscale");
tcg_register_helper(helper_fsin, "fsin");
tcg_register_helper(helper_fcos, "fcos");
tcg_register_helper(helper_fstenv, "fstenv");
tcg_register_helper(helper_fldenv, "fldenv");
tcg_register_helper(helper_fsave, "fsave");
tcg_register_helper(helper_frstor, "frstor");
tcg_register_helper(helper_fxsave, "fxsave");
tcg_register_helper(helper_fxrstor, "fxrstor");
tcg_register_helper(helper_bsf, "bsf");
tcg_register_helper(helper_bsr, "bsr");
tcg_register_helper(helper_lzcnt, "lzcnt");



tcg_register_helper(helper_enter_mmx, "enter_mmx");
tcg_register_helper(helper_emms, "emms");
tcg_register_helper(helper_movq, "movq");


# 1 "../../target-i386/ops_sse_header.h" 1
# 37 "../../target-i386/ops_sse_header.h"
tcg_register_helper(helper_psrlw_mmx, "psrlw_mmx");
tcg_register_helper(helper_psraw_mmx, "psraw_mmx");
tcg_register_helper(helper_psllw_mmx, "psllw_mmx");
tcg_register_helper(helper_psrld_mmx, "psrld_mmx");
tcg_register_helper(helper_psrad_mmx, "psrad_mmx");
tcg_register_helper(helper_pslld_mmx, "pslld_mmx");
tcg_register_helper(helper_psrlq_mmx, "psrlq_mmx");
tcg_register_helper(helper_psllq_mmx, "psllq_mmx");
# 63 "../../target-i386/ops_sse_header.h"
tcg_register_helper(helper_paddb_mmx, "paddb_mmx");
tcg_register_helper(helper_paddw_mmx, "paddw_mmx");
tcg_register_helper(helper_paddl_mmx, "paddl_mmx");
tcg_register_helper(helper_paddq_mmx, "paddq_mmx");

tcg_register_helper(helper_psubb_mmx, "psubb_mmx");
tcg_register_helper(helper_psubw_mmx, "psubw_mmx");
tcg_register_helper(helper_psubl_mmx, "psubl_mmx");
tcg_register_helper(helper_psubq_mmx, "psubq_mmx");

tcg_register_helper(helper_paddusb_mmx, "paddusb_mmx");
tcg_register_helper(helper_paddsb_mmx, "paddsb_mmx");
tcg_register_helper(helper_psubusb_mmx, "psubusb_mmx");
tcg_register_helper(helper_psubsb_mmx, "psubsb_mmx");

tcg_register_helper(helper_paddusw_mmx, "paddusw_mmx");
tcg_register_helper(helper_paddsw_mmx, "paddsw_mmx");
tcg_register_helper(helper_psubusw_mmx, "psubusw_mmx");
tcg_register_helper(helper_psubsw_mmx, "psubsw_mmx");

tcg_register_helper(helper_pminub_mmx, "pminub_mmx");
tcg_register_helper(helper_pmaxub_mmx, "pmaxub_mmx");

tcg_register_helper(helper_pminsw_mmx, "pminsw_mmx");
tcg_register_helper(helper_pmaxsw_mmx, "pmaxsw_mmx");

tcg_register_helper(helper_pand_mmx, "pand_mmx");
tcg_register_helper(helper_pandn_mmx, "pandn_mmx");
tcg_register_helper(helper_por_mmx, "por_mmx");
tcg_register_helper(helper_pxor_mmx, "pxor_mmx");

tcg_register_helper(helper_pcmpgtb_mmx, "pcmpgtb_mmx");
tcg_register_helper(helper_pcmpgtw_mmx, "pcmpgtw_mmx");
tcg_register_helper(helper_pcmpgtl_mmx, "pcmpgtl_mmx");

tcg_register_helper(helper_pcmpeqb_mmx, "pcmpeqb_mmx");
tcg_register_helper(helper_pcmpeqw_mmx, "pcmpeqw_mmx");
tcg_register_helper(helper_pcmpeql_mmx, "pcmpeql_mmx");

tcg_register_helper(helper_pmullw_mmx, "pmullw_mmx");

tcg_register_helper(helper_pmulhrw_mmx, "pmulhrw_mmx");

tcg_register_helper(helper_pmulhuw_mmx, "pmulhuw_mmx");
tcg_register_helper(helper_pmulhw_mmx, "pmulhw_mmx");

tcg_register_helper(helper_pavgb_mmx, "pavgb_mmx");
tcg_register_helper(helper_pavgw_mmx, "pavgw_mmx");

tcg_register_helper(helper_pmuludq_mmx, "pmuludq_mmx");
tcg_register_helper(helper_pmaddwd_mmx, "pmaddwd_mmx");

tcg_register_helper(helper_psadbw_mmx, "psadbw_mmx");
tcg_register_helper(helper_maskmov_mmx, "maskmov_mmx");
tcg_register_helper(helper_movl_mm_T0_mmx, "movl_mm_T0_mmx");

tcg_register_helper(helper_movq_mm_T0_mmx, "movq_mm_T0_mmx");



tcg_register_helper(helper_pshufw_mmx, "pshufw_mmx");
# 227 "../../target-i386/ops_sse_header.h"
tcg_register_helper(helper_pmovmskb_mmx, "pmovmskb_mmx");
tcg_register_helper(helper_packsswb_mmx, "packsswb_mmx");
tcg_register_helper(helper_packuswb_mmx, "packuswb_mmx");
tcg_register_helper(helper_packssdw_mmx, "packssdw_mmx");





tcg_register_helper(helper_punpcklbw_mmx, "punpcklbw_mmx"); tcg_register_helper(helper_punpcklwd_mmx, "punpcklwd_mmx"); tcg_register_helper(helper_punpckldq_mmx, "punpckldq_mmx");
tcg_register_helper(helper_punpckhbw_mmx, "punpckhbw_mmx"); tcg_register_helper(helper_punpckhwd_mmx, "punpckhwd_mmx"); tcg_register_helper(helper_punpckhdq_mmx, "punpckhdq_mmx");
# 246 "../../target-i386/ops_sse_header.h"
tcg_register_helper(helper_pi2fd, "pi2fd");
tcg_register_helper(helper_pi2fw, "pi2fw");
tcg_register_helper(helper_pf2id, "pf2id");
tcg_register_helper(helper_pf2iw, "pf2iw");
tcg_register_helper(helper_pfacc, "pfacc");
tcg_register_helper(helper_pfadd, "pfadd");
tcg_register_helper(helper_pfcmpeq, "pfcmpeq");
tcg_register_helper(helper_pfcmpge, "pfcmpge");
tcg_register_helper(helper_pfcmpgt, "pfcmpgt");
tcg_register_helper(helper_pfmax, "pfmax");
tcg_register_helper(helper_pfmin, "pfmin");
tcg_register_helper(helper_pfmul, "pfmul");
tcg_register_helper(helper_pfnacc, "pfnacc");
tcg_register_helper(helper_pfpnacc, "pfpnacc");
tcg_register_helper(helper_pfrcp, "pfrcp");
tcg_register_helper(helper_pfrsqrt, "pfrsqrt");
tcg_register_helper(helper_pfsub, "pfsub");
tcg_register_helper(helper_pfsubr, "pfsubr");
tcg_register_helper(helper_pswapd, "pswapd");



tcg_register_helper(helper_phaddw_mmx, "phaddw_mmx");
tcg_register_helper(helper_phaddd_mmx, "phaddd_mmx");
tcg_register_helper(helper_phaddsw_mmx, "phaddsw_mmx");
tcg_register_helper(helper_phsubw_mmx, "phsubw_mmx");
tcg_register_helper(helper_phsubd_mmx, "phsubd_mmx");
tcg_register_helper(helper_phsubsw_mmx, "phsubsw_mmx");
tcg_register_helper(helper_pabsb_mmx, "pabsb_mmx");
tcg_register_helper(helper_pabsw_mmx, "pabsw_mmx");
tcg_register_helper(helper_pabsd_mmx, "pabsd_mmx");
tcg_register_helper(helper_pmaddubsw_mmx, "pmaddubsw_mmx");
tcg_register_helper(helper_pmulhrsw_mmx, "pmulhrsw_mmx");
tcg_register_helper(helper_pshufb_mmx, "pshufb_mmx");
tcg_register_helper(helper_psignb_mmx, "psignb_mmx");
tcg_register_helper(helper_psignw_mmx, "psignw_mmx");
tcg_register_helper(helper_psignd_mmx, "psignd_mmx");
tcg_register_helper(helper_palignr_mmx, "palignr_mmx");
# 206 "../../target-i386/helper.h" 2

# 1 "../../target-i386/ops_sse_header.h" 1
# 37 "../../target-i386/ops_sse_header.h"
tcg_register_helper(helper_psrlw_xmm, "psrlw_xmm");
tcg_register_helper(helper_psraw_xmm, "psraw_xmm");
tcg_register_helper(helper_psllw_xmm, "psllw_xmm");
tcg_register_helper(helper_psrld_xmm, "psrld_xmm");
tcg_register_helper(helper_psrad_xmm, "psrad_xmm");
tcg_register_helper(helper_pslld_xmm, "pslld_xmm");
tcg_register_helper(helper_psrlq_xmm, "psrlq_xmm");
tcg_register_helper(helper_psllq_xmm, "psllq_xmm");


tcg_register_helper(helper_psrldq_xmm, "psrldq_xmm");
tcg_register_helper(helper_pslldq_xmm, "pslldq_xmm");
# 63 "../../target-i386/ops_sse_header.h"
tcg_register_helper(helper_paddb_xmm, "paddb_xmm");
tcg_register_helper(helper_paddw_xmm, "paddw_xmm");
tcg_register_helper(helper_paddl_xmm, "paddl_xmm");
tcg_register_helper(helper_paddq_xmm, "paddq_xmm");

tcg_register_helper(helper_psubb_xmm, "psubb_xmm");
tcg_register_helper(helper_psubw_xmm, "psubw_xmm");
tcg_register_helper(helper_psubl_xmm, "psubl_xmm");
tcg_register_helper(helper_psubq_xmm, "psubq_xmm");

tcg_register_helper(helper_paddusb_xmm, "paddusb_xmm");
tcg_register_helper(helper_paddsb_xmm, "paddsb_xmm");
tcg_register_helper(helper_psubusb_xmm, "psubusb_xmm");
tcg_register_helper(helper_psubsb_xmm, "psubsb_xmm");

tcg_register_helper(helper_paddusw_xmm, "paddusw_xmm");
tcg_register_helper(helper_paddsw_xmm, "paddsw_xmm");
tcg_register_helper(helper_psubusw_xmm, "psubusw_xmm");
tcg_register_helper(helper_psubsw_xmm, "psubsw_xmm");

tcg_register_helper(helper_pminub_xmm, "pminub_xmm");
tcg_register_helper(helper_pmaxub_xmm, "pmaxub_xmm");

tcg_register_helper(helper_pminsw_xmm, "pminsw_xmm");
tcg_register_helper(helper_pmaxsw_xmm, "pmaxsw_xmm");

tcg_register_helper(helper_pand_xmm, "pand_xmm");
tcg_register_helper(helper_pandn_xmm, "pandn_xmm");
tcg_register_helper(helper_por_xmm, "por_xmm");
tcg_register_helper(helper_pxor_xmm, "pxor_xmm");

tcg_register_helper(helper_pcmpgtb_xmm, "pcmpgtb_xmm");
tcg_register_helper(helper_pcmpgtw_xmm, "pcmpgtw_xmm");
tcg_register_helper(helper_pcmpgtl_xmm, "pcmpgtl_xmm");

tcg_register_helper(helper_pcmpeqb_xmm, "pcmpeqb_xmm");
tcg_register_helper(helper_pcmpeqw_xmm, "pcmpeqw_xmm");
tcg_register_helper(helper_pcmpeql_xmm, "pcmpeql_xmm");

tcg_register_helper(helper_pmullw_xmm, "pmullw_xmm");



tcg_register_helper(helper_pmulhuw_xmm, "pmulhuw_xmm");
tcg_register_helper(helper_pmulhw_xmm, "pmulhw_xmm");

tcg_register_helper(helper_pavgb_xmm, "pavgb_xmm");
tcg_register_helper(helper_pavgw_xmm, "pavgw_xmm");

tcg_register_helper(helper_pmuludq_xmm, "pmuludq_xmm");
tcg_register_helper(helper_pmaddwd_xmm, "pmaddwd_xmm");

tcg_register_helper(helper_psadbw_xmm, "psadbw_xmm");
tcg_register_helper(helper_maskmov_xmm, "maskmov_xmm");
tcg_register_helper(helper_movl_mm_T0_xmm, "movl_mm_T0_xmm");

tcg_register_helper(helper_movq_mm_T0_xmm, "movq_mm_T0_xmm");





tcg_register_helper(helper_shufps, "shufps");
tcg_register_helper(helper_shufpd, "shufpd");
tcg_register_helper(helper_pshufd_xmm, "pshufd_xmm");
tcg_register_helper(helper_pshuflw_xmm, "pshuflw_xmm");
tcg_register_helper(helper_pshufhw_xmm, "pshufhw_xmm");
# 142 "../../target-i386/ops_sse_header.h"
tcg_register_helper(helper_addps, "addps"); tcg_register_helper(helper_addss, "addss"); tcg_register_helper(helper_addpd, "addpd"); tcg_register_helper(helper_addsd, "addsd");
tcg_register_helper(helper_subps, "subps"); tcg_register_helper(helper_subss, "subss"); tcg_register_helper(helper_subpd, "subpd"); tcg_register_helper(helper_subsd, "subsd");
tcg_register_helper(helper_mulps, "mulps"); tcg_register_helper(helper_mulss, "mulss"); tcg_register_helper(helper_mulpd, "mulpd"); tcg_register_helper(helper_mulsd, "mulsd");
tcg_register_helper(helper_divps, "divps"); tcg_register_helper(helper_divss, "divss"); tcg_register_helper(helper_divpd, "divpd"); tcg_register_helper(helper_divsd, "divsd");
tcg_register_helper(helper_minps, "minps"); tcg_register_helper(helper_minss, "minss"); tcg_register_helper(helper_minpd, "minpd"); tcg_register_helper(helper_minsd, "minsd");
tcg_register_helper(helper_maxps, "maxps"); tcg_register_helper(helper_maxss, "maxss"); tcg_register_helper(helper_maxpd, "maxpd"); tcg_register_helper(helper_maxsd, "maxsd");
tcg_register_helper(helper_sqrtps, "sqrtps"); tcg_register_helper(helper_sqrtss, "sqrtss"); tcg_register_helper(helper_sqrtpd, "sqrtpd"); tcg_register_helper(helper_sqrtsd, "sqrtsd");


tcg_register_helper(helper_cvtps2pd, "cvtps2pd");
tcg_register_helper(helper_cvtpd2ps, "cvtpd2ps");
tcg_register_helper(helper_cvtss2sd, "cvtss2sd");
tcg_register_helper(helper_cvtsd2ss, "cvtsd2ss");
tcg_register_helper(helper_cvtdq2ps, "cvtdq2ps");
tcg_register_helper(helper_cvtdq2pd, "cvtdq2pd");
tcg_register_helper(helper_cvtpi2ps, "cvtpi2ps");
tcg_register_helper(helper_cvtpi2pd, "cvtpi2pd");
tcg_register_helper(helper_cvtsi2ss, "cvtsi2ss");
tcg_register_helper(helper_cvtsi2sd, "cvtsi2sd");


tcg_register_helper(helper_cvtsq2ss, "cvtsq2ss");
tcg_register_helper(helper_cvtsq2sd, "cvtsq2sd");


tcg_register_helper(helper_cvtps2dq, "cvtps2dq");
tcg_register_helper(helper_cvtpd2dq, "cvtpd2dq");
tcg_register_helper(helper_cvtps2pi, "cvtps2pi");
tcg_register_helper(helper_cvtpd2pi, "cvtpd2pi");
tcg_register_helper(helper_cvtss2si, "cvtss2si");
tcg_register_helper(helper_cvtsd2si, "cvtsd2si");

tcg_register_helper(helper_cvtss2sq, "cvtss2sq");
tcg_register_helper(helper_cvtsd2sq, "cvtsd2sq");


tcg_register_helper(helper_cvttps2dq, "cvttps2dq");
tcg_register_helper(helper_cvttpd2dq, "cvttpd2dq");
tcg_register_helper(helper_cvttps2pi, "cvttps2pi");
tcg_register_helper(helper_cvttpd2pi, "cvttpd2pi");
tcg_register_helper(helper_cvttss2si, "cvttss2si");
tcg_register_helper(helper_cvttsd2si, "cvttsd2si");

tcg_register_helper(helper_cvttss2sq, "cvttss2sq");
tcg_register_helper(helper_cvttsd2sq, "cvttsd2sq");


tcg_register_helper(helper_rsqrtps, "rsqrtps");
tcg_register_helper(helper_rsqrtss, "rsqrtss");
tcg_register_helper(helper_rcpps, "rcpps");
tcg_register_helper(helper_rcpss, "rcpss");
tcg_register_helper(helper_extrq_r, "extrq_r");
tcg_register_helper(helper_extrq_i, "extrq_i");
tcg_register_helper(helper_insertq_r, "insertq_r");
tcg_register_helper(helper_insertq_i, "insertq_i");
tcg_register_helper(helper_haddps, "haddps");
tcg_register_helper(helper_haddpd, "haddpd");
tcg_register_helper(helper_hsubps, "hsubps");
tcg_register_helper(helper_hsubpd, "hsubpd");
tcg_register_helper(helper_addsubps, "addsubps");
tcg_register_helper(helper_addsubpd, "addsubpd");







tcg_register_helper(helper_cmpeqps, "cmpeqps"); tcg_register_helper(helper_cmpeqss, "cmpeqss"); tcg_register_helper(helper_cmpeqpd, "cmpeqpd"); tcg_register_helper(helper_cmpeqsd, "cmpeqsd");
tcg_register_helper(helper_cmpltps, "cmpltps"); tcg_register_helper(helper_cmpltss, "cmpltss"); tcg_register_helper(helper_cmpltpd, "cmpltpd"); tcg_register_helper(helper_cmpltsd, "cmpltsd");
tcg_register_helper(helper_cmpleps, "cmpleps"); tcg_register_helper(helper_cmpless, "cmpless"); tcg_register_helper(helper_cmplepd, "cmplepd"); tcg_register_helper(helper_cmplesd, "cmplesd");
tcg_register_helper(helper_cmpunordps, "cmpunordps"); tcg_register_helper(helper_cmpunordss, "cmpunordss"); tcg_register_helper(helper_cmpunordpd, "cmpunordpd"); tcg_register_helper(helper_cmpunordsd, "cmpunordsd");
tcg_register_helper(helper_cmpneqps, "cmpneqps"); tcg_register_helper(helper_cmpneqss, "cmpneqss"); tcg_register_helper(helper_cmpneqpd, "cmpneqpd"); tcg_register_helper(helper_cmpneqsd, "cmpneqsd");
tcg_register_helper(helper_cmpnltps, "cmpnltps"); tcg_register_helper(helper_cmpnltss, "cmpnltss"); tcg_register_helper(helper_cmpnltpd, "cmpnltpd"); tcg_register_helper(helper_cmpnltsd, "cmpnltsd");
tcg_register_helper(helper_cmpnleps, "cmpnleps"); tcg_register_helper(helper_cmpnless, "cmpnless"); tcg_register_helper(helper_cmpnlepd, "cmpnlepd"); tcg_register_helper(helper_cmpnlesd, "cmpnlesd");
tcg_register_helper(helper_cmpordps, "cmpordps"); tcg_register_helper(helper_cmpordss, "cmpordss"); tcg_register_helper(helper_cmpordpd, "cmpordpd"); tcg_register_helper(helper_cmpordsd, "cmpordsd");

tcg_register_helper(helper_ucomiss, "ucomiss");
tcg_register_helper(helper_comiss, "comiss");
tcg_register_helper(helper_ucomisd, "ucomisd");
tcg_register_helper(helper_comisd, "comisd");
tcg_register_helper(helper_movmskps, "movmskps");
tcg_register_helper(helper_movmskpd, "movmskpd");


tcg_register_helper(helper_pmovmskb_xmm, "pmovmskb_xmm");
tcg_register_helper(helper_packsswb_xmm, "packsswb_xmm");
tcg_register_helper(helper_packuswb_xmm, "packuswb_xmm");
tcg_register_helper(helper_packssdw_xmm, "packssdw_xmm");





tcg_register_helper(helper_punpcklbw_xmm, "punpcklbw_xmm"); tcg_register_helper(helper_punpcklwd_xmm, "punpcklwd_xmm"); tcg_register_helper(helper_punpckldq_xmm, "punpckldq_xmm");
tcg_register_helper(helper_punpckhbw_xmm, "punpckhbw_xmm"); tcg_register_helper(helper_punpckhwd_xmm, "punpckhwd_xmm"); tcg_register_helper(helper_punpckhdq_xmm, "punpckhdq_xmm");


tcg_register_helper(helper_punpcklqdq_xmm, "punpcklqdq_xmm");
tcg_register_helper(helper_punpckhqdq_xmm, "punpckhqdq_xmm");
# 268 "../../target-i386/ops_sse_header.h"
tcg_register_helper(helper_phaddw_xmm, "phaddw_xmm");
tcg_register_helper(helper_phaddd_xmm, "phaddd_xmm");
tcg_register_helper(helper_phaddsw_xmm, "phaddsw_xmm");
tcg_register_helper(helper_phsubw_xmm, "phsubw_xmm");
tcg_register_helper(helper_phsubd_xmm, "phsubd_xmm");
tcg_register_helper(helper_phsubsw_xmm, "phsubsw_xmm");
tcg_register_helper(helper_pabsb_xmm, "pabsb_xmm");
tcg_register_helper(helper_pabsw_xmm, "pabsw_xmm");
tcg_register_helper(helper_pabsd_xmm, "pabsd_xmm");
tcg_register_helper(helper_pmaddubsw_xmm, "pmaddubsw_xmm");
tcg_register_helper(helper_pmulhrsw_xmm, "pmulhrsw_xmm");
tcg_register_helper(helper_pshufb_xmm, "pshufb_xmm");
tcg_register_helper(helper_psignb_xmm, "psignb_xmm");
tcg_register_helper(helper_psignw_xmm, "psignw_xmm");
tcg_register_helper(helper_psignd_xmm, "psignd_xmm");
tcg_register_helper(helper_palignr_xmm, "palignr_xmm");



tcg_register_helper(helper_pblendvb_xmm, "pblendvb_xmm");
tcg_register_helper(helper_blendvps_xmm, "blendvps_xmm");
tcg_register_helper(helper_blendvpd_xmm, "blendvpd_xmm");
tcg_register_helper(helper_ptest_xmm, "ptest_xmm");
tcg_register_helper(helper_pmovsxbw_xmm, "pmovsxbw_xmm");
tcg_register_helper(helper_pmovsxbd_xmm, "pmovsxbd_xmm");
tcg_register_helper(helper_pmovsxbq_xmm, "pmovsxbq_xmm");
tcg_register_helper(helper_pmovsxwd_xmm, "pmovsxwd_xmm");
tcg_register_helper(helper_pmovsxwq_xmm, "pmovsxwq_xmm");
tcg_register_helper(helper_pmovsxdq_xmm, "pmovsxdq_xmm");
tcg_register_helper(helper_pmovzxbw_xmm, "pmovzxbw_xmm");
tcg_register_helper(helper_pmovzxbd_xmm, "pmovzxbd_xmm");
tcg_register_helper(helper_pmovzxbq_xmm, "pmovzxbq_xmm");
tcg_register_helper(helper_pmovzxwd_xmm, "pmovzxwd_xmm");
tcg_register_helper(helper_pmovzxwq_xmm, "pmovzxwq_xmm");
tcg_register_helper(helper_pmovzxdq_xmm, "pmovzxdq_xmm");
tcg_register_helper(helper_pmuldq_xmm, "pmuldq_xmm");
tcg_register_helper(helper_pcmpeqq_xmm, "pcmpeqq_xmm");
tcg_register_helper(helper_packusdw_xmm, "packusdw_xmm");
tcg_register_helper(helper_pminsb_xmm, "pminsb_xmm");
tcg_register_helper(helper_pminsd_xmm, "pminsd_xmm");
tcg_register_helper(helper_pminuw_xmm, "pminuw_xmm");
tcg_register_helper(helper_pminud_xmm, "pminud_xmm");
tcg_register_helper(helper_pmaxsb_xmm, "pmaxsb_xmm");
tcg_register_helper(helper_pmaxsd_xmm, "pmaxsd_xmm");
tcg_register_helper(helper_pmaxuw_xmm, "pmaxuw_xmm");
tcg_register_helper(helper_pmaxud_xmm, "pmaxud_xmm");
tcg_register_helper(helper_pmulld_xmm, "pmulld_xmm");
tcg_register_helper(helper_phminposuw_xmm, "phminposuw_xmm");
tcg_register_helper(helper_roundps_xmm, "roundps_xmm");
tcg_register_helper(helper_roundpd_xmm, "roundpd_xmm");
tcg_register_helper(helper_roundss_xmm, "roundss_xmm");
tcg_register_helper(helper_roundsd_xmm, "roundsd_xmm");
tcg_register_helper(helper_blendps_xmm, "blendps_xmm");
tcg_register_helper(helper_blendpd_xmm, "blendpd_xmm");
tcg_register_helper(helper_pblendw_xmm, "pblendw_xmm");
tcg_register_helper(helper_dpps_xmm, "dpps_xmm");
tcg_register_helper(helper_dppd_xmm, "dppd_xmm");
tcg_register_helper(helper_mpsadbw_xmm, "mpsadbw_xmm");




tcg_register_helper(helper_pcmpgtq_xmm, "pcmpgtq_xmm");
tcg_register_helper(helper_pcmpestri_xmm, "pcmpestri_xmm");
tcg_register_helper(helper_pcmpestrm_xmm, "pcmpestrm_xmm");
tcg_register_helper(helper_pcmpistri_xmm, "pcmpistri_xmm");
tcg_register_helper(helper_pcmpistrm_xmm, "pcmpistrm_xmm");
tcg_register_helper(helper_crc32, "crc32");
tcg_register_helper(helper_popcnt, "popcnt");
# 208 "../../target-i386/helper.h" 2

tcg_register_helper(helper_rclb, "rclb");
tcg_register_helper(helper_rclw, "rclw");
tcg_register_helper(helper_rcll, "rcll");
tcg_register_helper(helper_rcrb, "rcrb");
tcg_register_helper(helper_rcrw, "rcrw");
tcg_register_helper(helper_rcrl, "rcrl");

tcg_register_helper(helper_rclq, "rclq");
tcg_register_helper(helper_rcrq, "rcrq");


# 1 "../../def-helper.h" 1
# 220 "../../target-i386/helper.h" 2
# 7701 "../../target-i386/translate.c" 2
}




static __attribute__ (( always_inline )) __inline__ void gen_intermediate_code_internal(struct CPUX86State *env,
                                                  TranslationBlock *tb,
                                                  int search_pc)
{
    DisasContext dc1, *dc = &dc1;
    target_ulong pc_ptr;
    uint16_t *gen_opc_end;
    CPUBreakpoint *bp;
    int j, lj;
    uint64_t flags;
    target_ulong pc_start;
    target_ulong cs_base;
    int num_insns;
    int max_insns;


    pc_start = tb->pc;
    cs_base = tb->cs_base;
    flags = tb->flags;

    dc->pe = (flags >> 7) & 1;
    dc->code32 = (flags >> 4) & 1;
    dc->ss32 = (flags >> 5) & 1;
    dc->addseg = (flags >> 6) & 1;
    dc->f_st = 0;
    dc->vm86 = (flags >> 17) & 1;
    dc->cpl = (flags >> 0) & 3;
    dc->iopl = (flags >> 12) & 3;
    dc->tf = (flags >> 8) & 1;
    dc->singlestep_enabled = env->singlestep_enabled;
    dc->cc_op = CC_OP_DYNAMIC;
    dc->cs_base = cs_base;
    dc->tb = tb;
    dc->popl_esp_hack = 0;

    dc->mem_index = 0;
    if (flags & (1 << 2)) {
        if (dc->cpl == 3)
            dc->mem_index = 2 * 4;
        else
            dc->mem_index = 1 * 4;
    }
    dc->cpuid_features = env->cpuid_features;
    dc->cpuid_ext_features = env->cpuid_ext_features;
    dc->cpuid_ext2_features = env->cpuid_ext2_features;
    dc->cpuid_ext3_features = env->cpuid_ext3_features;

    dc->lma = (flags >> 14) & 1;
    dc->code64 = (flags >> 15) & 1;

    dc->flags = flags;
    dc->jmp_opt = !(dc->tf || env->singlestep_enabled ||
                    (flags & (1 << 3))



                    );






    cpu_T[0] = tcg_temp_new_i64();
    cpu_T[1] = tcg_temp_new_i64();
    cpu_A0 = tcg_temp_new_i64();
    cpu_T3 = tcg_temp_new_i64();

    cpu_tmp0 = tcg_temp_new_i64();
    cpu_tmp1_i64 = tcg_temp_new_i64();
    cpu_tmp2_i32 = tcg_temp_new_i32();
    cpu_tmp3_i32 = tcg_temp_new_i32();
    cpu_tmp4 = tcg_temp_new_i64();
    cpu_tmp5 = tcg_temp_new_i64();
    cpu_ptr0 = tcg_temp_new_i32();
    cpu_ptr1 = tcg_temp_new_i32();

    gen_opc_end = gen_opc_buf + (640 - 96);

    dc->is_jmp = 0;
    pc_ptr = pc_start;
    lj = -1;
    num_insns = 0;
    max_insns = tb->cflags & 0x7fff;
    if (max_insns == 0)
        max_insns = 0x7fff;

    gen_icount_start();
    for(;;) {
        if (__builtin_expect(!!(!((&env->breakpoints)->tqh_first == ((void *)0))), 0)) {
            for ((bp) = ((&env->breakpoints)->tqh_first); (bp); (bp) = ((bp)->entry.tqe_next)) {
                if (bp->pc == pc_ptr &&
                    !((bp->flags & 0x20) && (tb->flags & (1 << 16)))) {
                    gen_debug(dc, pc_ptr - dc->cs_base);
                    break;
                }
            }
        }
        if (search_pc) {
            j = gen_opc_ptr - gen_opc_buf;
            if (lj < j) {
                lj++;
                while (lj < j)
                    gen_opc_instr_start[lj++] = 0;
            }
            gen_opc_pc[lj] = pc_ptr;
            gen_opc_cc_op[lj] = dc->cc_op;
            gen_opc_instr_start[lj] = 1;
            gen_opc_icount[lj] = num_insns;
        }
        if (num_insns + 1 == max_insns && (tb->cflags & 0x8000))
            gen_io_start();

        pc_ptr = disas_insn(dc, pc_ptr);
        num_insns++;

        if (dc->is_jmp)
            break;





        if (dc->tf || dc->singlestep_enabled ||
            (flags & (1 << 3))) {
            gen_jmp_im(pc_ptr - dc->cs_base);
            gen_eob(dc);
            break;
        }

        if (gen_opc_ptr >= gen_opc_end ||
            (pc_ptr - pc_start) >= ((1 << 12) - 32) ||
            num_insns >= max_insns) {
            gen_jmp_im(pc_ptr - dc->cs_base);
            gen_eob(dc);
            break;
        }
        if (singlestep) {
            gen_jmp_im(pc_ptr - dc->cs_base);
            gen_eob(dc);
            break;
        }
    }
    if (tb->cflags & 0x8000)
        gen_io_end();
    gen_icount_end(tb, num_insns);
    *gen_opc_ptr = INDEX_op_end;

    if (search_pc) {
        j = gen_opc_ptr - gen_opc_buf;
        lj++;
        while (lj <= j)
            gen_opc_instr_start[lj++] = 0;
    }


    if (((loglevel & ((1 << 1))) != 0)) {
        int disas_flags;
        do { if (logfile) fprintf(logfile,"----------------\n"); } while (0);
        do { if (logfile) fprintf(logfile,"IN: %s\n", lookup_symbol(pc_start)); } while (0);

        if (dc->code64)
            disas_flags = 2;
        else

            disas_flags = !dc->code32;
        target_disas(logfile, (pc_start), (pc_ptr - pc_start), (disas_flags));
        do { if (logfile) fprintf(logfile,"\n"); } while (0);
    }


    if (!search_pc) {
        tb->size = pc_ptr - pc_start;
        tb->icount = num_insns;
    }
}

void gen_intermediate_code(struct CPUX86State *env, TranslationBlock *tb)
{
    gen_intermediate_code_internal(env, tb, 0);
}

void gen_intermediate_code_pc(struct CPUX86State *env, TranslationBlock *tb)
{
    gen_intermediate_code_internal(env, tb, 1);
}

void gen_pc_load(struct CPUX86State *env, TranslationBlock *tb,
                unsigned long searched_pc, int pc_pos, void *puc)
{
    int cc_op;

    if (((loglevel & ((1 << 2))) != 0)) {
        int i;
        do { if (logfile) fprintf(logfile,"RESTORE:\n"); } while (0);
        for(i = 0;i <= pc_pos; i++) {
            if (gen_opc_instr_start[i]) {
                do { if (logfile) fprintf(logfile,"0x%04x: " "%016" "ll" "x" "\n", i, gen_opc_pc[i]); } while (0);
            }
        }
        do { if (logfile) fprintf(logfile,"spc=0x%08lx pc_pos=0x%x eip=" "%016" "ll" "x" " cs_base=%x\n", searched_pc, pc_pos, gen_opc_pc[pc_pos] - tb->cs_base, (uint32_t)tb->cs_base); } while (0)

                                      ;
    }

    env->eip = gen_opc_pc[pc_pos] - tb->cs_base;
    cc_op = gen_opc_cc_op[pc_pos];
    if (cc_op != CC_OP_DYNAMIC)
        env->cc_op = cc_op;
}