# 1 "ipret.c"
# 1 "<built-in>" 1
# 1 "<built-in>" 3
# 402 "<built-in>" 3
# 1 "<command line>" 1
# 1 "<built-in>" 2
# 1 "ipret.c" 2
# 19 "ipret.c"
# 1 "./ajla.h" 1
# 19 "./ajla.h"
# 1 "./config-m.h" 1
# 57 "./config-m.h"
# 1 "./version.h" 1
# 58 "./config-m.h" 2



# 1 "./config.h" 1
# 62 "./config-m.h" 2
# 20 "./ajla.h" 2


# 1 "/usr/include/x86_64-linux-gnu/sys/types.h" 1 3 4
# 25 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 394 "/usr/include/features.h" 3 4
# 1 "/usr/include/features-time64.h" 1 3 4
# 20 "/usr/include/features-time64.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 21 "/usr/include/features-time64.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 1 3 4
# 19 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 20 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 2 3 4
# 22 "/usr/include/features-time64.h" 2 3 4
# 395 "/usr/include/features.h" 2 3 4
# 480 "/usr/include/features.h" 3 4
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 481 "/usr/include/features.h" 2 3 4
# 502 "/usr/include/features.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 1 3 4
# 576 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 577 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/long-double.h" 1 3 4
# 578 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4
# 503 "/usr/include/features.h" 2 3 4
# 526 "/usr/include/features.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 1 3 4
# 10 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs-64.h" 1 3 4
# 11 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 2 3 4
# 527 "/usr/include/features.h" 2 3 4
# 26 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4



# 1 "/usr/include/x86_64-linux-gnu/bits/types.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 28 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 1 3 4
# 19 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 20 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 2 3 4
# 29 "/usr/include/x86_64-linux-gnu/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;

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






typedef __int8_t __int_least8_t;
typedef __uint8_t __uint_least8_t;
typedef __int16_t __int_least16_t;
typedef __uint16_t __uint_least16_t;
typedef __int32_t __int_least32_t;
typedef __uint32_t __uint_least32_t;
typedef __int64_t __int_least64_t;
typedef __uint64_t __uint_least64_t;



typedef long int __quad_t;
typedef unsigned long int __u_quad_t;







typedef long int __intmax_t;
typedef unsigned long int __uintmax_t;
# 141 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/typesizes.h" 1 3 4
# 142 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/time64.h" 1 3 4
# 143 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4


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

typedef int __daddr_t;
typedef int __key_t;


typedef int __clockid_t;


typedef void * __timer_t;


typedef long int __blksize_t;




typedef long int __blkcnt_t;
typedef long int __blkcnt64_t;


typedef unsigned long int __fsblkcnt_t;
typedef unsigned long int __fsblkcnt64_t;


typedef unsigned long int __fsfilcnt_t;
typedef unsigned long int __fsfilcnt64_t;


typedef long int __fsword_t;

typedef long int __ssize_t;


typedef long int __syscall_slong_t;

typedef unsigned long int __syscall_ulong_t;



typedef __off64_t __loff_t;
typedef char *__caddr_t;


typedef long int __intptr_t;


typedef unsigned int __socklen_t;




typedef int __sig_atomic_t;
# 30 "/usr/include/x86_64-linux-gnu/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;




# 1 "/usr/include/x86_64-linux-gnu/bits/types/clock_t.h" 1 3 4






typedef __clock_t clock_t;
# 127 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4

# 1 "/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h" 1 3 4






typedef __clockid_t clockid_t;
# 129 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/time_t.h" 1 3 4
# 10 "/usr/include/x86_64-linux-gnu/bits/types/time_t.h" 3 4
typedef __time_t time_t;
# 130 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/timer_t.h" 1 3 4






typedef __timer_t timer_t;
# 131 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4



typedef __useconds_t useconds_t;



typedef __suseconds_t suseconds_t;





# 1 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 1 3 4
# 93 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 3 4
# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_size_t.h" 1 3 4
# 18 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 94 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3 4
# 145 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4



typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;




# 1 "/usr/include/x86_64-linux-gnu/bits/stdint-intn.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/stdint-intn.h" 3 4
typedef __int8_t int8_t;
typedef __int16_t int16_t;
typedef __int32_t int32_t;
typedef __int64_t int64_t;
# 156 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4


typedef __uint8_t u_int8_t;
typedef __uint16_t u_int16_t;
typedef __uint32_t u_int32_t;
typedef __uint64_t u_int64_t;


typedef int register_t __attribute__ ((__mode__ (__word__)));
# 176 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
# 1 "/usr/include/endian.h" 1 3 4
# 24 "/usr/include/endian.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/endian.h" 1 3 4
# 35 "/usr/include/x86_64-linux-gnu/bits/endian.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/endianness.h" 1 3 4
# 36 "/usr/include/x86_64-linux-gnu/bits/endian.h" 2 3 4
# 25 "/usr/include/endian.h" 2 3 4
# 35 "/usr/include/endian.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 1 3 4
# 33 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4
static __inline __uint16_t
__bswap_16 (__uint16_t __bsx)
{



  return ((__uint16_t) ((((__bsx) >> 8) & 0xff) | (((__bsx) & 0xff) << 8)));

}






static __inline __uint32_t
__bswap_32 (__uint32_t __bsx)
{



  return ((((__bsx) & 0xff000000u) >> 24) | (((__bsx) & 0x00ff0000u) >> 8) | (((__bsx) & 0x0000ff00u) << 8) | (((__bsx) & 0x000000ffu) << 24));

}
# 69 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4
__extension__ static __inline __uint64_t
__bswap_64 (__uint64_t __bsx)
{



  return ((((__bsx) & 0xff00000000000000ull) >> 56) | (((__bsx) & 0x00ff000000000000ull) >> 40) | (((__bsx) & 0x0000ff0000000000ull) >> 24) | (((__bsx) & 0x000000ff00000000ull) >> 8) | (((__bsx) & 0x00000000ff000000ull) << 8) | (((__bsx) & 0x0000000000ff0000ull) << 24) | (((__bsx) & 0x000000000000ff00ull) << 40) | (((__bsx) & 0x00000000000000ffull) << 56));

}
# 36 "/usr/include/endian.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 1 3 4
# 32 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 3 4
static __inline __uint16_t
__uint16_identity (__uint16_t __x)
{
  return __x;
}

static __inline __uint32_t
__uint32_identity (__uint32_t __x)
{
  return __x;
}

static __inline __uint64_t
__uint64_identity (__uint64_t __x)
{
  return __x;
}
# 37 "/usr/include/endian.h" 2 3 4
# 177 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4


# 1 "/usr/include/x86_64-linux-gnu/sys/select.h" 1 3 4
# 30 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/select.h" 1 3 4
# 31 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4


# 1 "/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h" 1 3 4



# 1 "/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h" 1 3 4




typedef struct
{
  unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
} __sigset_t;
# 5 "/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h" 2 3 4


typedef __sigset_t sigset_t;
# 34 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4



# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h" 1 3 4







struct timeval
{




  __time_t tv_sec;
  __suseconds_t tv_usec;

};
# 38 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4

# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 1 3 4
# 11 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 4
struct timespec
{



  __time_t tv_sec;




  __syscall_slong_t tv_nsec;
# 31 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 4
};
# 40 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
# 49 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
typedef long int __fd_mask;
# 59 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
typedef struct
  {



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





  } fd_set;






typedef __fd_mask fd_mask;
# 102 "/usr/include/x86_64-linux-gnu/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);
# 127 "/usr/include/x86_64-linux-gnu/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);
# 180 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4





typedef __blksize_t blksize_t;
# 205 "/usr/include/x86_64-linux-gnu/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/x86_64-linux-gnu/bits/pthreadtypes.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 1 3 4
# 44 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 1 3 4
# 21 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 2 3 4
# 45 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4

# 1 "/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h" 1 3 4
# 25 "/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h" 3 4
typedef union
{
  __extension__ unsigned long long int __value64;
  struct
  {
    unsigned int __low;
    unsigned int __high;
  } __value32;
} __atomic_wide_counter;
# 47 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4




typedef struct __pthread_internal_list
{
  struct __pthread_internal_list *__prev;
  struct __pthread_internal_list *__next;
} __pthread_list_t;

typedef struct __pthread_internal_slist
{
  struct __pthread_internal_slist *__next;
} __pthread_slist_t;
# 76 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 3 4
struct __pthread_mutex_s
{
  int __lock;
  unsigned int __count;
  int __owner;

  unsigned int __nusers;



  int __kind;

  short __spins;
  short __elision;
  __pthread_list_t __list;
# 53 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 3 4
};
# 77 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4
# 89 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 3 4
struct __pthread_rwlock_arch_t
{
  unsigned int __readers;
  unsigned int __writers;
  unsigned int __wrphase_futex;
  unsigned int __writers_futex;
  unsigned int __pad3;
  unsigned int __pad4;

  int __cur_writer;
  int __shared;
  signed char __rwelision;




  unsigned char __pad1[7];


  unsigned long int __pad2;


  unsigned int __flags;
# 55 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 3 4
};
# 90 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4




struct __pthread_cond_s
{
  __atomic_wide_counter __wseq;
  __atomic_wide_counter __g1_start;
  unsigned int __g_refs[2] ;
  unsigned int __g_size[2];
  unsigned int __g1_orig_size;
  unsigned int __wrefs;
  unsigned int __g_signals[2];
};

typedef unsigned int __tss_t;
typedef unsigned long int __thrd_t;

typedef struct
{
  int __data ;
} __once_flag;
# 24 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 2 3 4



typedef unsigned long int pthread_t;




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




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



typedef unsigned int pthread_key_t;



typedef int pthread_once_t;


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

typedef union pthread_attr_t pthread_attr_t;




typedef union
{
  struct __pthread_mutex_s __data;
  char __size[40];
  long int __align;
} pthread_mutex_t;


typedef union
{
  struct __pthread_cond_s __data;
  char __size[48];
  __extension__ long long int __align;
} pthread_cond_t;





typedef union
{
  struct __pthread_rwlock_arch_t __data;
  char __size[56];
  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[32];
  long int __align;
} pthread_barrier_t;

typedef union
{
  char __size[4];
  int __align;
} pthread_barrierattr_t;
# 228 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 23 "./ajla.h" 2




# 1 "/usr/lib/llvm-20/lib/clang/20/include/stdarg.h" 1 3
# 47 "/usr/lib/llvm-20/lib/clang/20/include/stdarg.h" 3
# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stdarg_header_macro.h" 1 3
# 48 "/usr/lib/llvm-20/lib/clang/20/include/stdarg.h" 2 3



# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stdarg___gnuc_va_list.h" 1 3
# 12 "/usr/lib/llvm-20/lib/clang/20/include/__stdarg___gnuc_va_list.h" 3
typedef __builtin_va_list __gnuc_va_list;
# 52 "/usr/lib/llvm-20/lib/clang/20/include/stdarg.h" 2 3




# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stdarg_va_list.h" 1 3
# 12 "/usr/lib/llvm-20/lib/clang/20/include/__stdarg_va_list.h" 3
typedef __builtin_va_list va_list;
# 57 "/usr/lib/llvm-20/lib/clang/20/include/stdarg.h" 2 3




# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stdarg_va_arg.h" 1 3
# 62 "/usr/lib/llvm-20/lib/clang/20/include/stdarg.h" 2 3




# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stdarg___va_copy.h" 1 3
# 67 "/usr/lib/llvm-20/lib/clang/20/include/stdarg.h" 2 3




# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stdarg_va_copy.h" 1 3
# 72 "/usr/lib/llvm-20/lib/clang/20/include/stdarg.h" 2 3
# 28 "./ajla.h" 2
# 1 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 1 3
# 84 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 3
# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_header_macro.h" 1 3
# 85 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3



# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_ptrdiff_t.h" 1 3
# 18 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_ptrdiff_t.h" 3
typedef long int ptrdiff_t;
# 89 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3




# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_size_t.h" 1 3
# 94 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3
# 103 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 3
# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_wchar_t.h" 1 3
# 24 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_wchar_t.h" 3
typedef int wchar_t;
# 104 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3




# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_null.h" 1 3
# 109 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3
# 123 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 3
# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_max_align_t.h" 1 3
# 19 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_max_align_t.h" 3
typedef struct {
  long long __clang_max_align_nonce1
      __attribute__((__aligned__(__alignof__(long long))));
  long double __clang_max_align_nonce2
      __attribute__((__aligned__(__alignof__(long double))));
} max_align_t;
# 124 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3




# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_offsetof.h" 1 3
# 129 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3
# 29 "./ajla.h" 2
# 1 "/usr/lib/llvm-20/lib/clang/20/include/float.h" 1 3
# 30 "./ajla.h" 2
# 1 "/usr/include/math.h" 1 3 4
# 27 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 28 "/usr/include/math.h" 2 3 4
# 40 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/math-vector.h" 1 3 4
# 25 "/usr/include/x86_64-linux-gnu/bits/math-vector.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/bits/math-vector.h" 2 3 4
# 41 "/usr/include/math.h" 2 3 4


# 1 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 1 3 4
# 120 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/long-double.h" 1 3 4
# 25 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 2 3 4
# 214 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
typedef float _Float32;
# 251 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
typedef double _Float64;
# 268 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
typedef double _Float32x;
# 285 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
typedef long double _Float64x;
# 121 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 2 3 4
# 44 "/usr/include/math.h" 2 3 4
# 152 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h" 1 3 4
# 153 "/usr/include/math.h" 2 3 4
# 163 "/usr/include/math.h" 3 4
typedef float float_t;
typedef double double_t;
# 204 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/fp-logb.h" 1 3 4
# 205 "/usr/include/math.h" 2 3 4
# 247 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/fp-fast.h" 1 3 4
# 248 "/usr/include/math.h" 2 3 4



enum
  {
    FP_INT_UPWARD =

      0,
    FP_INT_DOWNWARD =

      1,
    FP_INT_TOWARDZERO =

      2,
    FP_INT_TONEARESTFROMZERO =

      3,
    FP_INT_TONEAREST =

      4,
  };
# 312 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4
# 20 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4
extern int __fpclassify (double __value) __attribute__ ((__nothrow__ ))
     __attribute__ ((__const__));


extern int __signbit (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 int __isnan (double __value) __attribute__ ((__nothrow__ ))
  __attribute__ ((__const__));


extern int __iseqsig (double __x, double __y) __attribute__ ((__nothrow__ ));


extern int __issignaling (double __value) __attribute__ ((__nothrow__ ))
     __attribute__ ((__const__));
# 313 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/x86_64-linux-gnu/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__ )) __attribute__ ((__nonnull__ (2)));



 extern double exp10 (double __x) __attribute__ ((__nothrow__ )); extern double __exp10 (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__ ));
# 177 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
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__ )); extern double __nan (const char *__tagb) __attribute__ ((__nothrow__ ));
# 213 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
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__ )); extern double __nextafter (double __x, double __y) __attribute__ ((__nothrow__ ));

extern double nexttoward (double __x, long double __y) __attribute__ ((__nothrow__ )); extern double __nexttoward (double __x, long double __y) __attribute__ ((__nothrow__ ));




extern double nextdown (double __x) __attribute__ ((__nothrow__ )); extern double __nextdown (double __x) __attribute__ ((__nothrow__ ));

extern double nextup (double __x) __attribute__ ((__nothrow__ )); extern double __nextup (double __x) __attribute__ ((__nothrow__ ));



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 long int llogb (double __x) __attribute__ ((__nothrow__ )); extern long int __llogb (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__ ));
__extension__
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__ ));
__extension__
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__ )) __attribute__ ((__const__)); extern double __fmax (double __x, double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern double fmin (double __x, double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern double __fmin (double __x, double __y) __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 roundeven (double __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern double __roundeven (double __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));



extern __intmax_t fromfp (double __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __intmax_t __fromfp (double __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));




extern __uintmax_t ufromfp (double __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __uintmax_t __ufromfp (double __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));





extern __intmax_t fromfpx (double __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __intmax_t __fromfpx (double __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));





extern __uintmax_t ufromfpx (double __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __uintmax_t __ufromfpx (double __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));



extern int canonicalize (double *__cx, const double *__x) __attribute__ ((__nothrow__ ));






extern double fmaxmag (double __x, double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern double __fmaxmag (double __x, double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern double fminmag (double __x, double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern double __fminmag (double __x, double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern double fmaximum (double __x, double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern double __fmaximum (double __x, double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern double fminimum (double __x, double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern double __fminimum (double __x, double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern double fmaximum_num (double __x, double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern double __fmaximum_num (double __x, double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern double fminimum_num (double __x, double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern double __fminimum_num (double __x, double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern double fmaximum_mag (double __x, double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern double __fmaximum_mag (double __x, double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern double fminimum_mag (double __x, double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern double __fminimum_mag (double __x, double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern double fmaximum_mag_num (double __x, double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern double __fmaximum_mag_num (double __x, double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern double fminimum_mag_num (double __x, double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern double __fminimum_mag_num (double __x, double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern int totalorder (const double *__x, const double *__y) __attribute__ ((__nothrow__ ))

     __attribute__ ((__pure__));


extern int totalordermag (const double *__x, const double *__y) __attribute__ ((__nothrow__ ))

     __attribute__ ((__pure__));


extern double getpayload (const double *__x) __attribute__ ((__nothrow__ )); extern double __getpayload (const double *__x) __attribute__ ((__nothrow__ ));


extern int setpayload (double *__x, double __payload) __attribute__ ((__nothrow__ ));


extern int setpayloadsig (double *__x, double __payload) __attribute__ ((__nothrow__ ));







extern double scalb (double __x, double __n) __attribute__ ((__nothrow__ )); extern double __scalb (double __x, double __n) __attribute__ ((__nothrow__ ));
# 314 "/usr/include/math.h" 2 3 4
# 329 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4
# 20 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4
extern int __fpclassifyf (float __value) __attribute__ ((__nothrow__ ))
     __attribute__ ((__const__));


extern int __signbitf (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 int __isnanf (float __value) __attribute__ ((__nothrow__ ))
  __attribute__ ((__const__));


extern int __iseqsigf (float __x, float __y) __attribute__ ((__nothrow__ ));


extern int __issignalingf (float __value) __attribute__ ((__nothrow__ ))
     __attribute__ ((__const__));
# 330 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/x86_64-linux-gnu/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 (float __x, float *__sinx, float *__cosx) __attribute__ ((__nothrow__ )); extern void __sincosf (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__ )) __attribute__ ((__nonnull__ (2)));



 extern float exp10f (float __x) __attribute__ ((__nothrow__ )); extern float __exp10f (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__ ));
# 177 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
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__ )); extern float __nanf (const char *__tagb) __attribute__ ((__nothrow__ ));
# 213 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
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__ )); extern float __nextafterf (float __x, float __y) __attribute__ ((__nothrow__ ));

extern float nexttowardf (float __x, long double __y) __attribute__ ((__nothrow__ )); extern float __nexttowardf (float __x, long double __y) __attribute__ ((__nothrow__ ));




extern float nextdownf (float __x) __attribute__ ((__nothrow__ )); extern float __nextdownf (float __x) __attribute__ ((__nothrow__ ));

extern float nextupf (float __x) __attribute__ ((__nothrow__ )); extern float __nextupf (float __x) __attribute__ ((__nothrow__ ));



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 long int llogbf (float __x) __attribute__ ((__nothrow__ )); extern long int __llogbf (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__ ));
__extension__
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__ ));
__extension__
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__ )) __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern float fminf (float __x, float __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern float __fminf (float __x, float __y) __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 roundevenf (float __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern float __roundevenf (float __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));



extern __intmax_t fromfpf (float __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __intmax_t __fromfpf (float __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));




extern __uintmax_t ufromfpf (float __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __uintmax_t __ufromfpf (float __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));





extern __intmax_t fromfpxf (float __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __intmax_t __fromfpxf (float __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));





extern __uintmax_t ufromfpxf (float __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __uintmax_t __ufromfpxf (float __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));



extern int canonicalizef (float *__cx, const float *__x) __attribute__ ((__nothrow__ ));






extern float fmaxmagf (float __x, float __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern float __fmaxmagf (float __x, float __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern float fminmagf (float __x, float __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern float __fminmagf (float __x, float __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern float fmaximumf (float __x, float __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern float __fmaximumf (float __x, float __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern float fminimumf (float __x, float __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern float __fminimumf (float __x, float __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern float fmaximum_numf (float __x, float __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern float __fmaximum_numf (float __x, float __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern float fminimum_numf (float __x, float __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern float __fminimum_numf (float __x, float __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern float fmaximum_magf (float __x, float __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern float __fmaximum_magf (float __x, float __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern float fminimum_magf (float __x, float __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern float __fminimum_magf (float __x, float __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern float fmaximum_mag_numf (float __x, float __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern float __fmaximum_mag_numf (float __x, float __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern float fminimum_mag_numf (float __x, float __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern float __fminimum_mag_numf (float __x, float __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern int totalorderf (const float *__x, const float *__y) __attribute__ ((__nothrow__ ))

     __attribute__ ((__pure__));


extern int totalordermagf (const float *__x, const float *__y) __attribute__ ((__nothrow__ ))

     __attribute__ ((__pure__));


extern float getpayloadf (const float *__x) __attribute__ ((__nothrow__ )); extern float __getpayloadf (const float *__x) __attribute__ ((__nothrow__ ));


extern int setpayloadf (float *__x, float __payload) __attribute__ ((__nothrow__ ));


extern int setpayloadsigf (float *__x, float __payload) __attribute__ ((__nothrow__ ));







extern float scalbf (float __x, float __n) __attribute__ ((__nothrow__ )); extern float __scalbf (float __x, float __n) __attribute__ ((__nothrow__ ));
# 331 "/usr/include/math.h" 2 3 4
# 398 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4
# 20 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4
extern int __fpclassifyl (long double __value) __attribute__ ((__nothrow__ ))
     __attribute__ ((__const__));


extern int __signbitl (long double __value) __attribute__ ((__nothrow__ ))
     __attribute__ ((__const__));



extern int __isinfl (long double __value) __attribute__ ((__nothrow__ ))
  __attribute__ ((__const__));


extern int __finitel (long double __value) __attribute__ ((__nothrow__ ))
  __attribute__ ((__const__));


extern int __isnanl (long double __value) __attribute__ ((__nothrow__ ))
  __attribute__ ((__const__));


extern int __iseqsigl (long double __x, long double __y) __attribute__ ((__nothrow__ ));


extern int __issignalingl (long double __value) __attribute__ ((__nothrow__ ))
     __attribute__ ((__const__));
# 399 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
 extern long double acosl (long double __x) __attribute__ ((__nothrow__ )); extern long double __acosl (long double __x) __attribute__ ((__nothrow__ ));

 extern long double asinl (long double __x) __attribute__ ((__nothrow__ )); extern long double __asinl (long double __x) __attribute__ ((__nothrow__ ));

 extern long double atanl (long double __x) __attribute__ ((__nothrow__ )); extern long double __atanl (long double __x) __attribute__ ((__nothrow__ ));

 extern long double atan2l (long double __y, long double __x) __attribute__ ((__nothrow__ )); extern long double __atan2l (long double __y, long double __x) __attribute__ ((__nothrow__ ));


 extern long double cosl (long double __x) __attribute__ ((__nothrow__ )); extern long double __cosl (long double __x) __attribute__ ((__nothrow__ ));

 extern long double sinl (long double __x) __attribute__ ((__nothrow__ )); extern long double __sinl (long double __x) __attribute__ ((__nothrow__ ));

 extern long double tanl (long double __x) __attribute__ ((__nothrow__ )); extern long double __tanl (long double __x) __attribute__ ((__nothrow__ ));




 extern long double coshl (long double __x) __attribute__ ((__nothrow__ )); extern long double __coshl (long double __x) __attribute__ ((__nothrow__ ));

 extern long double sinhl (long double __x) __attribute__ ((__nothrow__ )); extern long double __sinhl (long double __x) __attribute__ ((__nothrow__ ));

 extern long double tanhl (long double __x) __attribute__ ((__nothrow__ )); extern long double __tanhl (long double __x) __attribute__ ((__nothrow__ ));



 extern void sincosl (long double __x, long double *__sinx, long double *__cosx) __attribute__ ((__nothrow__ )); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) __attribute__ ((__nothrow__ ));





 extern long double acoshl (long double __x) __attribute__ ((__nothrow__ )); extern long double __acoshl (long double __x) __attribute__ ((__nothrow__ ));

 extern long double asinhl (long double __x) __attribute__ ((__nothrow__ )); extern long double __asinhl (long double __x) __attribute__ ((__nothrow__ ));

 extern long double atanhl (long double __x) __attribute__ ((__nothrow__ )); extern long double __atanhl (long double __x) __attribute__ ((__nothrow__ ));





 extern long double expl (long double __x) __attribute__ ((__nothrow__ )); extern long double __expl (long double __x) __attribute__ ((__nothrow__ ));


extern long double frexpl (long double __x, int *__exponent) __attribute__ ((__nothrow__ )); extern long double __frexpl (long double __x, int *__exponent) __attribute__ ((__nothrow__ ));


extern long double ldexpl (long double __x, int __exponent) __attribute__ ((__nothrow__ )); extern long double __ldexpl (long double __x, int __exponent) __attribute__ ((__nothrow__ ));


 extern long double logl (long double __x) __attribute__ ((__nothrow__ )); extern long double __logl (long double __x) __attribute__ ((__nothrow__ ));


 extern long double log10l (long double __x) __attribute__ ((__nothrow__ )); extern long double __log10l (long double __x) __attribute__ ((__nothrow__ ));


extern long double modfl (long double __x, long double *__iptr) __attribute__ ((__nothrow__ )); extern long double __modfl (long double __x, long double *__iptr) __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (2)));



 extern long double exp10l (long double __x) __attribute__ ((__nothrow__ )); extern long double __exp10l (long double __x) __attribute__ ((__nothrow__ ));




 extern long double expm1l (long double __x) __attribute__ ((__nothrow__ )); extern long double __expm1l (long double __x) __attribute__ ((__nothrow__ ));


 extern long double log1pl (long double __x) __attribute__ ((__nothrow__ )); extern long double __log1pl (long double __x) __attribute__ ((__nothrow__ ));


extern long double logbl (long double __x) __attribute__ ((__nothrow__ )); extern long double __logbl (long double __x) __attribute__ ((__nothrow__ ));




 extern long double exp2l (long double __x) __attribute__ ((__nothrow__ )); extern long double __exp2l (long double __x) __attribute__ ((__nothrow__ ));


 extern long double log2l (long double __x) __attribute__ ((__nothrow__ )); extern long double __log2l (long double __x) __attribute__ ((__nothrow__ ));






 extern long double powl (long double __x, long double __y) __attribute__ ((__nothrow__ )); extern long double __powl (long double __x, long double __y) __attribute__ ((__nothrow__ ));


extern long double sqrtl (long double __x) __attribute__ ((__nothrow__ )); extern long double __sqrtl (long double __x) __attribute__ ((__nothrow__ ));



 extern long double hypotl (long double __x, long double __y) __attribute__ ((__nothrow__ )); extern long double __hypotl (long double __x, long double __y) __attribute__ ((__nothrow__ ));




 extern long double cbrtl (long double __x) __attribute__ ((__nothrow__ )); extern long double __cbrtl (long double __x) __attribute__ ((__nothrow__ ));






extern long double ceill (long double __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern long double __ceill (long double __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern long double fabsl (long double __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern long double __fabsl (long double __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern long double floorl (long double __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern long double __floorl (long double __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern long double fmodl (long double __x, long double __y) __attribute__ ((__nothrow__ )); extern long double __fmodl (long double __x, long double __y) __attribute__ ((__nothrow__ ));
# 177 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern int isinfl (long double __value) __attribute__ ((__nothrow__ ))
  __attribute__ ((__const__));




extern int finitel (long double __value) __attribute__ ((__nothrow__ ))
  __attribute__ ((__const__));


extern long double dreml (long double __x, long double __y) __attribute__ ((__nothrow__ )); extern long double __dreml (long double __x, long double __y) __attribute__ ((__nothrow__ ));



extern long double significandl (long double __x) __attribute__ ((__nothrow__ )); extern long double __significandl (long double __x) __attribute__ ((__nothrow__ ));






extern long double copysignl (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern long double nanl (const char *__tagb) __attribute__ ((__nothrow__ )); extern long double __nanl (const char *__tagb) __attribute__ ((__nothrow__ ));
# 213 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern int isnanl (long double __value) __attribute__ ((__nothrow__ ))
  __attribute__ ((__const__));





extern long double j0l (long double) __attribute__ ((__nothrow__ )); extern long double __j0l (long double) __attribute__ ((__nothrow__ ));
extern long double j1l (long double) __attribute__ ((__nothrow__ )); extern long double __j1l (long double) __attribute__ ((__nothrow__ ));
extern long double jnl (int, long double) __attribute__ ((__nothrow__ )); extern long double __jnl (int, long double) __attribute__ ((__nothrow__ ));
extern long double y0l (long double) __attribute__ ((__nothrow__ )); extern long double __y0l (long double) __attribute__ ((__nothrow__ ));
extern long double y1l (long double) __attribute__ ((__nothrow__ )); extern long double __y1l (long double) __attribute__ ((__nothrow__ ));
extern long double ynl (int, long double) __attribute__ ((__nothrow__ )); extern long double __ynl (int, long double) __attribute__ ((__nothrow__ ));





 extern long double erfl (long double) __attribute__ ((__nothrow__ )); extern long double __erfl (long double) __attribute__ ((__nothrow__ ));
 extern long double erfcl (long double) __attribute__ ((__nothrow__ )); extern long double __erfcl (long double) __attribute__ ((__nothrow__ ));
extern long double lgammal (long double) __attribute__ ((__nothrow__ )); extern long double __lgammal (long double) __attribute__ ((__nothrow__ ));




extern long double tgammal (long double) __attribute__ ((__nothrow__ )); extern long double __tgammal (long double) __attribute__ ((__nothrow__ ));





extern long double gammal (long double) __attribute__ ((__nothrow__ )); extern long double __gammal (long double) __attribute__ ((__nothrow__ ));







extern long double lgammal_r (long double, int *__signgamp) __attribute__ ((__nothrow__ )); extern long double __lgammal_r (long double, int *__signgamp) __attribute__ ((__nothrow__ ));






extern long double rintl (long double __x) __attribute__ ((__nothrow__ )); extern long double __rintl (long double __x) __attribute__ ((__nothrow__ ));


extern long double nextafterl (long double __x, long double __y) __attribute__ ((__nothrow__ )); extern long double __nextafterl (long double __x, long double __y) __attribute__ ((__nothrow__ ));

extern long double nexttowardl (long double __x, long double __y) __attribute__ ((__nothrow__ )); extern long double __nexttowardl (long double __x, long double __y) __attribute__ ((__nothrow__ ));




extern long double nextdownl (long double __x) __attribute__ ((__nothrow__ )); extern long double __nextdownl (long double __x) __attribute__ ((__nothrow__ ));

extern long double nextupl (long double __x) __attribute__ ((__nothrow__ )); extern long double __nextupl (long double __x) __attribute__ ((__nothrow__ ));



extern long double remainderl (long double __x, long double __y) __attribute__ ((__nothrow__ )); extern long double __remainderl (long double __x, long double __y) __attribute__ ((__nothrow__ ));



extern long double scalbnl (long double __x, int __n) __attribute__ ((__nothrow__ )); extern long double __scalbnl (long double __x, int __n) __attribute__ ((__nothrow__ ));



extern int ilogbl (long double __x) __attribute__ ((__nothrow__ )); extern int __ilogbl (long double __x) __attribute__ ((__nothrow__ ));




extern long int llogbl (long double __x) __attribute__ ((__nothrow__ )); extern long int __llogbl (long double __x) __attribute__ ((__nothrow__ ));




extern long double scalblnl (long double __x, long int __n) __attribute__ ((__nothrow__ )); extern long double __scalblnl (long double __x, long int __n) __attribute__ ((__nothrow__ ));



extern long double nearbyintl (long double __x) __attribute__ ((__nothrow__ )); extern long double __nearbyintl (long double __x) __attribute__ ((__nothrow__ ));



extern long double roundl (long double __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern long double __roundl (long double __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));



extern long double truncl (long double __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern long double __truncl (long double __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern long double remquol (long double __x, long double __y, int *__quo) __attribute__ ((__nothrow__ )); extern long double __remquol (long double __x, long double __y, int *__quo) __attribute__ ((__nothrow__ ));






extern long int lrintl (long double __x) __attribute__ ((__nothrow__ )); extern long int __lrintl (long double __x) __attribute__ ((__nothrow__ ));
__extension__
extern long long int llrintl (long double __x) __attribute__ ((__nothrow__ )); extern long long int __llrintl (long double __x) __attribute__ ((__nothrow__ ));



extern long int lroundl (long double __x) __attribute__ ((__nothrow__ )); extern long int __lroundl (long double __x) __attribute__ ((__nothrow__ ));
__extension__
extern long long int llroundl (long double __x) __attribute__ ((__nothrow__ )); extern long long int __llroundl (long double __x) __attribute__ ((__nothrow__ ));



extern long double fdiml (long double __x, long double __y) __attribute__ ((__nothrow__ )); extern long double __fdiml (long double __x, long double __y) __attribute__ ((__nothrow__ ));



extern long double fmaxl (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern long double fminl (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));



extern long double fmal (long double __x, long double __y, long double __z) __attribute__ ((__nothrow__ )); extern long double __fmal (long double __x, long double __y, long double __z) __attribute__ ((__nothrow__ ));




extern long double roundevenl (long double __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern long double __roundevenl (long double __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));



extern __intmax_t fromfpl (long double __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __intmax_t __fromfpl (long double __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));




extern __uintmax_t ufromfpl (long double __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __uintmax_t __ufromfpl (long double __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));





extern __intmax_t fromfpxl (long double __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __intmax_t __fromfpxl (long double __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));





extern __uintmax_t ufromfpxl (long double __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __uintmax_t __ufromfpxl (long double __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));



extern int canonicalizel (long double *__cx, const long double *__x) __attribute__ ((__nothrow__ ));






extern long double fmaxmagl (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern long double __fmaxmagl (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern long double fminmagl (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern long double __fminmagl (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern long double fmaximuml (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern long double __fmaximuml (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern long double fminimuml (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern long double __fminimuml (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern long double fmaximum_numl (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern long double __fmaximum_numl (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern long double fminimum_numl (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern long double __fminimum_numl (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern long double fmaximum_magl (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern long double __fmaximum_magl (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern long double fminimum_magl (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern long double __fminimum_magl (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern long double fmaximum_mag_numl (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern long double __fmaximum_mag_numl (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern long double fminimum_mag_numl (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern long double __fminimum_mag_numl (long double __x, long double __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern int totalorderl (const long double *__x, const long double *__y) __attribute__ ((__nothrow__ ))

     __attribute__ ((__pure__));


extern int totalordermagl (const long double *__x, const long double *__y) __attribute__ ((__nothrow__ ))

     __attribute__ ((__pure__));


extern long double getpayloadl (const long double *__x) __attribute__ ((__nothrow__ )); extern long double __getpayloadl (const long double *__x) __attribute__ ((__nothrow__ ));


extern int setpayloadl (long double *__x, long double __payload) __attribute__ ((__nothrow__ ));


extern int setpayloadsigl (long double *__x, long double __payload) __attribute__ ((__nothrow__ ));







extern long double scalbl (long double __x, long double __n) __attribute__ ((__nothrow__ )); extern long double __scalbl (long double __x, long double __n) __attribute__ ((__nothrow__ ));
# 400 "/usr/include/math.h" 2 3 4
# 450 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
 extern _Float32 acosf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __acosf32 (_Float32 __x) __attribute__ ((__nothrow__ ));

 extern _Float32 asinf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __asinf32 (_Float32 __x) __attribute__ ((__nothrow__ ));

 extern _Float32 atanf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __atanf32 (_Float32 __x) __attribute__ ((__nothrow__ ));

 extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __atan2f32 (_Float32 __y, _Float32 __x) __attribute__ ((__nothrow__ ));


 extern _Float32 cosf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __cosf32 (_Float32 __x) __attribute__ ((__nothrow__ ));

 extern _Float32 sinf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __sinf32 (_Float32 __x) __attribute__ ((__nothrow__ ));

 extern _Float32 tanf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __tanf32 (_Float32 __x) __attribute__ ((__nothrow__ ));




 extern _Float32 coshf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __coshf32 (_Float32 __x) __attribute__ ((__nothrow__ ));

 extern _Float32 sinhf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __sinhf32 (_Float32 __x) __attribute__ ((__nothrow__ ));

 extern _Float32 tanhf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __tanhf32 (_Float32 __x) __attribute__ ((__nothrow__ ));



 extern void sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) __attribute__ ((__nothrow__ )); extern void __sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) __attribute__ ((__nothrow__ ));





 extern _Float32 acoshf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __acoshf32 (_Float32 __x) __attribute__ ((__nothrow__ ));

 extern _Float32 asinhf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __asinhf32 (_Float32 __x) __attribute__ ((__nothrow__ ));

 extern _Float32 atanhf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __atanhf32 (_Float32 __x) __attribute__ ((__nothrow__ ));





 extern _Float32 expf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __expf32 (_Float32 __x) __attribute__ ((__nothrow__ ));


extern _Float32 frexpf32 (_Float32 __x, int *__exponent) __attribute__ ((__nothrow__ )); extern _Float32 __frexpf32 (_Float32 __x, int *__exponent) __attribute__ ((__nothrow__ ));


extern _Float32 ldexpf32 (_Float32 __x, int __exponent) __attribute__ ((__nothrow__ )); extern _Float32 __ldexpf32 (_Float32 __x, int __exponent) __attribute__ ((__nothrow__ ));


 extern _Float32 logf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __logf32 (_Float32 __x) __attribute__ ((__nothrow__ ));


 extern _Float32 log10f32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __log10f32 (_Float32 __x) __attribute__ ((__nothrow__ ));


extern _Float32 modff32 (_Float32 __x, _Float32 *__iptr) __attribute__ ((__nothrow__ )); extern _Float32 __modff32 (_Float32 __x, _Float32 *__iptr) __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (2)));



 extern _Float32 exp10f32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __exp10f32 (_Float32 __x) __attribute__ ((__nothrow__ ));




 extern _Float32 expm1f32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __expm1f32 (_Float32 __x) __attribute__ ((__nothrow__ ));


 extern _Float32 log1pf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __log1pf32 (_Float32 __x) __attribute__ ((__nothrow__ ));


extern _Float32 logbf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __logbf32 (_Float32 __x) __attribute__ ((__nothrow__ ));




 extern _Float32 exp2f32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __exp2f32 (_Float32 __x) __attribute__ ((__nothrow__ ));


 extern _Float32 log2f32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __log2f32 (_Float32 __x) __attribute__ ((__nothrow__ ));






 extern _Float32 powf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )); extern _Float32 __powf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ ));


extern _Float32 sqrtf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __sqrtf32 (_Float32 __x) __attribute__ ((__nothrow__ ));



 extern _Float32 hypotf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )); extern _Float32 __hypotf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ ));




 extern _Float32 cbrtf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __cbrtf32 (_Float32 __x) __attribute__ ((__nothrow__ ));






extern _Float32 ceilf32 (_Float32 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32 __ceilf32 (_Float32 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32 fabsf32 (_Float32 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32 __fabsf32 (_Float32 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32 floorf32 (_Float32 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32 __floorf32 (_Float32 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32 fmodf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )); extern _Float32 __fmodf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ ));
# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float32 copysignf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32 __copysignf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern _Float32 nanf32 (const char *__tagb) __attribute__ ((__nothrow__ )); extern _Float32 __nanf32 (const char *__tagb) __attribute__ ((__nothrow__ ));
# 220 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float32 j0f32 (_Float32) __attribute__ ((__nothrow__ )); extern _Float32 __j0f32 (_Float32) __attribute__ ((__nothrow__ ));
extern _Float32 j1f32 (_Float32) __attribute__ ((__nothrow__ )); extern _Float32 __j1f32 (_Float32) __attribute__ ((__nothrow__ ));
extern _Float32 jnf32 (int, _Float32) __attribute__ ((__nothrow__ )); extern _Float32 __jnf32 (int, _Float32) __attribute__ ((__nothrow__ ));
extern _Float32 y0f32 (_Float32) __attribute__ ((__nothrow__ )); extern _Float32 __y0f32 (_Float32) __attribute__ ((__nothrow__ ));
extern _Float32 y1f32 (_Float32) __attribute__ ((__nothrow__ )); extern _Float32 __y1f32 (_Float32) __attribute__ ((__nothrow__ ));
extern _Float32 ynf32 (int, _Float32) __attribute__ ((__nothrow__ )); extern _Float32 __ynf32 (int, _Float32) __attribute__ ((__nothrow__ ));





 extern _Float32 erff32 (_Float32) __attribute__ ((__nothrow__ )); extern _Float32 __erff32 (_Float32) __attribute__ ((__nothrow__ ));
 extern _Float32 erfcf32 (_Float32) __attribute__ ((__nothrow__ )); extern _Float32 __erfcf32 (_Float32) __attribute__ ((__nothrow__ ));
extern _Float32 lgammaf32 (_Float32) __attribute__ ((__nothrow__ )); extern _Float32 __lgammaf32 (_Float32) __attribute__ ((__nothrow__ ));




extern _Float32 tgammaf32 (_Float32) __attribute__ ((__nothrow__ )); extern _Float32 __tgammaf32 (_Float32) __attribute__ ((__nothrow__ ));
# 252 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float32 lgammaf32_r (_Float32, int *__signgamp) __attribute__ ((__nothrow__ )); extern _Float32 __lgammaf32_r (_Float32, int *__signgamp) __attribute__ ((__nothrow__ ));






extern _Float32 rintf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __rintf32 (_Float32 __x) __attribute__ ((__nothrow__ ));


extern _Float32 nextafterf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )); extern _Float32 __nextafterf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ ));






extern _Float32 nextdownf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __nextdownf32 (_Float32 __x) __attribute__ ((__nothrow__ ));

extern _Float32 nextupf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __nextupf32 (_Float32 __x) __attribute__ ((__nothrow__ ));



extern _Float32 remainderf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )); extern _Float32 __remainderf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ ));



extern _Float32 scalbnf32 (_Float32 __x, int __n) __attribute__ ((__nothrow__ )); extern _Float32 __scalbnf32 (_Float32 __x, int __n) __attribute__ ((__nothrow__ ));



extern int ilogbf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern int __ilogbf32 (_Float32 __x) __attribute__ ((__nothrow__ ));




extern long int llogbf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern long int __llogbf32 (_Float32 __x) __attribute__ ((__nothrow__ ));




extern _Float32 scalblnf32 (_Float32 __x, long int __n) __attribute__ ((__nothrow__ )); extern _Float32 __scalblnf32 (_Float32 __x, long int __n) __attribute__ ((__nothrow__ ));



extern _Float32 nearbyintf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern _Float32 __nearbyintf32 (_Float32 __x) __attribute__ ((__nothrow__ ));



extern _Float32 roundf32 (_Float32 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32 __roundf32 (_Float32 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));



extern _Float32 truncf32 (_Float32 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32 __truncf32 (_Float32 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern _Float32 remquof32 (_Float32 __x, _Float32 __y, int *__quo) __attribute__ ((__nothrow__ )); extern _Float32 __remquof32 (_Float32 __x, _Float32 __y, int *__quo) __attribute__ ((__nothrow__ ));






extern long int lrintf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern long int __lrintf32 (_Float32 __x) __attribute__ ((__nothrow__ ));
__extension__
extern long long int llrintf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern long long int __llrintf32 (_Float32 __x) __attribute__ ((__nothrow__ ));



extern long int lroundf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern long int __lroundf32 (_Float32 __x) __attribute__ ((__nothrow__ ));
__extension__
extern long long int llroundf32 (_Float32 __x) __attribute__ ((__nothrow__ )); extern long long int __llroundf32 (_Float32 __x) __attribute__ ((__nothrow__ ));



extern _Float32 fdimf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )); extern _Float32 __fdimf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ ));



extern _Float32 fmaxf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32 __fmaxf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32 fminf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32 __fminf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));



extern _Float32 fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) __attribute__ ((__nothrow__ )); extern _Float32 __fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) __attribute__ ((__nothrow__ ));




extern _Float32 roundevenf32 (_Float32 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32 __roundevenf32 (_Float32 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));



extern __intmax_t fromfpf32 (_Float32 __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __intmax_t __fromfpf32 (_Float32 __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));




extern __uintmax_t ufromfpf32 (_Float32 __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __uintmax_t __ufromfpf32 (_Float32 __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));





extern __intmax_t fromfpxf32 (_Float32 __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __intmax_t __fromfpxf32 (_Float32 __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));





extern __uintmax_t ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __uintmax_t __ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));



extern int canonicalizef32 (_Float32 *__cx, const _Float32 *__x) __attribute__ ((__nothrow__ ));






extern _Float32 fmaxmagf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32 __fmaxmagf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32 fminmagf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32 __fminmagf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern _Float32 fmaximumf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32 __fmaximumf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32 fminimumf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32 __fminimumf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32 fmaximum_numf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32 __fmaximum_numf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32 fminimum_numf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32 __fminimum_numf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32 fmaximum_magf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32 __fmaximum_magf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32 fminimum_magf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32 __fminimum_magf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32 fmaximum_mag_numf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32 __fmaximum_mag_numf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32 fminimum_mag_numf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32 __fminimum_mag_numf32 (_Float32 __x, _Float32 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern int totalorderf32 (const _Float32 *__x, const _Float32 *__y) __attribute__ ((__nothrow__ ))

     __attribute__ ((__pure__));


extern int totalordermagf32 (const _Float32 *__x, const _Float32 *__y) __attribute__ ((__nothrow__ ))

     __attribute__ ((__pure__));


extern _Float32 getpayloadf32 (const _Float32 *__x) __attribute__ ((__nothrow__ )); extern _Float32 __getpayloadf32 (const _Float32 *__x) __attribute__ ((__nothrow__ ));


extern int setpayloadf32 (_Float32 *__x, _Float32 __payload) __attribute__ ((__nothrow__ ));


extern int setpayloadsigf32 (_Float32 *__x, _Float32 __payload) __attribute__ ((__nothrow__ ));
# 451 "/usr/include/math.h" 2 3 4
# 467 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
 extern _Float64 acosf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __acosf64 (_Float64 __x) __attribute__ ((__nothrow__ ));

 extern _Float64 asinf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __asinf64 (_Float64 __x) __attribute__ ((__nothrow__ ));

 extern _Float64 atanf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __atanf64 (_Float64 __x) __attribute__ ((__nothrow__ ));

 extern _Float64 atan2f64 (_Float64 __y, _Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __atan2f64 (_Float64 __y, _Float64 __x) __attribute__ ((__nothrow__ ));


 extern _Float64 cosf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __cosf64 (_Float64 __x) __attribute__ ((__nothrow__ ));

 extern _Float64 sinf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __sinf64 (_Float64 __x) __attribute__ ((__nothrow__ ));

 extern _Float64 tanf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __tanf64 (_Float64 __x) __attribute__ ((__nothrow__ ));




 extern _Float64 coshf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __coshf64 (_Float64 __x) __attribute__ ((__nothrow__ ));

 extern _Float64 sinhf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __sinhf64 (_Float64 __x) __attribute__ ((__nothrow__ ));

 extern _Float64 tanhf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __tanhf64 (_Float64 __x) __attribute__ ((__nothrow__ ));



 extern void sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) __attribute__ ((__nothrow__ )); extern void __sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) __attribute__ ((__nothrow__ ));





 extern _Float64 acoshf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __acoshf64 (_Float64 __x) __attribute__ ((__nothrow__ ));

 extern _Float64 asinhf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __asinhf64 (_Float64 __x) __attribute__ ((__nothrow__ ));

 extern _Float64 atanhf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __atanhf64 (_Float64 __x) __attribute__ ((__nothrow__ ));





 extern _Float64 expf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __expf64 (_Float64 __x) __attribute__ ((__nothrow__ ));


extern _Float64 frexpf64 (_Float64 __x, int *__exponent) __attribute__ ((__nothrow__ )); extern _Float64 __frexpf64 (_Float64 __x, int *__exponent) __attribute__ ((__nothrow__ ));


extern _Float64 ldexpf64 (_Float64 __x, int __exponent) __attribute__ ((__nothrow__ )); extern _Float64 __ldexpf64 (_Float64 __x, int __exponent) __attribute__ ((__nothrow__ ));


 extern _Float64 logf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __logf64 (_Float64 __x) __attribute__ ((__nothrow__ ));


 extern _Float64 log10f64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __log10f64 (_Float64 __x) __attribute__ ((__nothrow__ ));


extern _Float64 modff64 (_Float64 __x, _Float64 *__iptr) __attribute__ ((__nothrow__ )); extern _Float64 __modff64 (_Float64 __x, _Float64 *__iptr) __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (2)));



 extern _Float64 exp10f64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __exp10f64 (_Float64 __x) __attribute__ ((__nothrow__ ));




 extern _Float64 expm1f64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __expm1f64 (_Float64 __x) __attribute__ ((__nothrow__ ));


 extern _Float64 log1pf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __log1pf64 (_Float64 __x) __attribute__ ((__nothrow__ ));


extern _Float64 logbf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __logbf64 (_Float64 __x) __attribute__ ((__nothrow__ ));




 extern _Float64 exp2f64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __exp2f64 (_Float64 __x) __attribute__ ((__nothrow__ ));


 extern _Float64 log2f64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __log2f64 (_Float64 __x) __attribute__ ((__nothrow__ ));






 extern _Float64 powf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )); extern _Float64 __powf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ ));


extern _Float64 sqrtf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __sqrtf64 (_Float64 __x) __attribute__ ((__nothrow__ ));



 extern _Float64 hypotf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )); extern _Float64 __hypotf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ ));




 extern _Float64 cbrtf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __cbrtf64 (_Float64 __x) __attribute__ ((__nothrow__ ));






extern _Float64 ceilf64 (_Float64 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64 __ceilf64 (_Float64 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64 fabsf64 (_Float64 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64 __fabsf64 (_Float64 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64 floorf64 (_Float64 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64 __floorf64 (_Float64 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64 fmodf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )); extern _Float64 __fmodf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ ));
# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float64 copysignf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64 __copysignf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern _Float64 nanf64 (const char *__tagb) __attribute__ ((__nothrow__ )); extern _Float64 __nanf64 (const char *__tagb) __attribute__ ((__nothrow__ ));
# 220 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float64 j0f64 (_Float64) __attribute__ ((__nothrow__ )); extern _Float64 __j0f64 (_Float64) __attribute__ ((__nothrow__ ));
extern _Float64 j1f64 (_Float64) __attribute__ ((__nothrow__ )); extern _Float64 __j1f64 (_Float64) __attribute__ ((__nothrow__ ));
extern _Float64 jnf64 (int, _Float64) __attribute__ ((__nothrow__ )); extern _Float64 __jnf64 (int, _Float64) __attribute__ ((__nothrow__ ));
extern _Float64 y0f64 (_Float64) __attribute__ ((__nothrow__ )); extern _Float64 __y0f64 (_Float64) __attribute__ ((__nothrow__ ));
extern _Float64 y1f64 (_Float64) __attribute__ ((__nothrow__ )); extern _Float64 __y1f64 (_Float64) __attribute__ ((__nothrow__ ));
extern _Float64 ynf64 (int, _Float64) __attribute__ ((__nothrow__ )); extern _Float64 __ynf64 (int, _Float64) __attribute__ ((__nothrow__ ));





 extern _Float64 erff64 (_Float64) __attribute__ ((__nothrow__ )); extern _Float64 __erff64 (_Float64) __attribute__ ((__nothrow__ ));
 extern _Float64 erfcf64 (_Float64) __attribute__ ((__nothrow__ )); extern _Float64 __erfcf64 (_Float64) __attribute__ ((__nothrow__ ));
extern _Float64 lgammaf64 (_Float64) __attribute__ ((__nothrow__ )); extern _Float64 __lgammaf64 (_Float64) __attribute__ ((__nothrow__ ));




extern _Float64 tgammaf64 (_Float64) __attribute__ ((__nothrow__ )); extern _Float64 __tgammaf64 (_Float64) __attribute__ ((__nothrow__ ));
# 252 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float64 lgammaf64_r (_Float64, int *__signgamp) __attribute__ ((__nothrow__ )); extern _Float64 __lgammaf64_r (_Float64, int *__signgamp) __attribute__ ((__nothrow__ ));






extern _Float64 rintf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __rintf64 (_Float64 __x) __attribute__ ((__nothrow__ ));


extern _Float64 nextafterf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )); extern _Float64 __nextafterf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ ));






extern _Float64 nextdownf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __nextdownf64 (_Float64 __x) __attribute__ ((__nothrow__ ));

extern _Float64 nextupf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __nextupf64 (_Float64 __x) __attribute__ ((__nothrow__ ));



extern _Float64 remainderf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )); extern _Float64 __remainderf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ ));



extern _Float64 scalbnf64 (_Float64 __x, int __n) __attribute__ ((__nothrow__ )); extern _Float64 __scalbnf64 (_Float64 __x, int __n) __attribute__ ((__nothrow__ ));



extern int ilogbf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern int __ilogbf64 (_Float64 __x) __attribute__ ((__nothrow__ ));




extern long int llogbf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern long int __llogbf64 (_Float64 __x) __attribute__ ((__nothrow__ ));




extern _Float64 scalblnf64 (_Float64 __x, long int __n) __attribute__ ((__nothrow__ )); extern _Float64 __scalblnf64 (_Float64 __x, long int __n) __attribute__ ((__nothrow__ ));



extern _Float64 nearbyintf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern _Float64 __nearbyintf64 (_Float64 __x) __attribute__ ((__nothrow__ ));



extern _Float64 roundf64 (_Float64 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64 __roundf64 (_Float64 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));



extern _Float64 truncf64 (_Float64 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64 __truncf64 (_Float64 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern _Float64 remquof64 (_Float64 __x, _Float64 __y, int *__quo) __attribute__ ((__nothrow__ )); extern _Float64 __remquof64 (_Float64 __x, _Float64 __y, int *__quo) __attribute__ ((__nothrow__ ));






extern long int lrintf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern long int __lrintf64 (_Float64 __x) __attribute__ ((__nothrow__ ));
__extension__
extern long long int llrintf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern long long int __llrintf64 (_Float64 __x) __attribute__ ((__nothrow__ ));



extern long int lroundf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern long int __lroundf64 (_Float64 __x) __attribute__ ((__nothrow__ ));
__extension__
extern long long int llroundf64 (_Float64 __x) __attribute__ ((__nothrow__ )); extern long long int __llroundf64 (_Float64 __x) __attribute__ ((__nothrow__ ));



extern _Float64 fdimf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )); extern _Float64 __fdimf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ ));



extern _Float64 fmaxf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64 __fmaxf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64 fminf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64 __fminf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));



extern _Float64 fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) __attribute__ ((__nothrow__ )); extern _Float64 __fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) __attribute__ ((__nothrow__ ));




extern _Float64 roundevenf64 (_Float64 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64 __roundevenf64 (_Float64 __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));



extern __intmax_t fromfpf64 (_Float64 __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __intmax_t __fromfpf64 (_Float64 __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));




extern __uintmax_t ufromfpf64 (_Float64 __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __uintmax_t __ufromfpf64 (_Float64 __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));





extern __intmax_t fromfpxf64 (_Float64 __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __intmax_t __fromfpxf64 (_Float64 __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));





extern __uintmax_t ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __uintmax_t __ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));



extern int canonicalizef64 (_Float64 *__cx, const _Float64 *__x) __attribute__ ((__nothrow__ ));






extern _Float64 fmaxmagf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64 __fmaxmagf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64 fminmagf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64 __fminmagf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern _Float64 fmaximumf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64 __fmaximumf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64 fminimumf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64 __fminimumf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64 fmaximum_numf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64 __fmaximum_numf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64 fminimum_numf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64 __fminimum_numf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64 fmaximum_magf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64 __fmaximum_magf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64 fminimum_magf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64 __fminimum_magf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64 fmaximum_mag_numf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64 __fmaximum_mag_numf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64 fminimum_mag_numf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64 __fminimum_mag_numf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern int totalorderf64 (const _Float64 *__x, const _Float64 *__y) __attribute__ ((__nothrow__ ))

     __attribute__ ((__pure__));


extern int totalordermagf64 (const _Float64 *__x, const _Float64 *__y) __attribute__ ((__nothrow__ ))

     __attribute__ ((__pure__));


extern _Float64 getpayloadf64 (const _Float64 *__x) __attribute__ ((__nothrow__ )); extern _Float64 __getpayloadf64 (const _Float64 *__x) __attribute__ ((__nothrow__ ));


extern int setpayloadf64 (_Float64 *__x, _Float64 __payload) __attribute__ ((__nothrow__ ));


extern int setpayloadsigf64 (_Float64 *__x, _Float64 __payload) __attribute__ ((__nothrow__ ));
# 468 "/usr/include/math.h" 2 3 4
# 501 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
 extern _Float32x acosf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __acosf32x (_Float32x __x) __attribute__ ((__nothrow__ ));

 extern _Float32x asinf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __asinf32x (_Float32x __x) __attribute__ ((__nothrow__ ));

 extern _Float32x atanf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __atanf32x (_Float32x __x) __attribute__ ((__nothrow__ ));

 extern _Float32x atan2f32x (_Float32x __y, _Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __atan2f32x (_Float32x __y, _Float32x __x) __attribute__ ((__nothrow__ ));


 extern _Float32x cosf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __cosf32x (_Float32x __x) __attribute__ ((__nothrow__ ));

 extern _Float32x sinf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __sinf32x (_Float32x __x) __attribute__ ((__nothrow__ ));

 extern _Float32x tanf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __tanf32x (_Float32x __x) __attribute__ ((__nothrow__ ));




 extern _Float32x coshf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __coshf32x (_Float32x __x) __attribute__ ((__nothrow__ ));

 extern _Float32x sinhf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __sinhf32x (_Float32x __x) __attribute__ ((__nothrow__ ));

 extern _Float32x tanhf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __tanhf32x (_Float32x __x) __attribute__ ((__nothrow__ ));



 extern void sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) __attribute__ ((__nothrow__ )); extern void __sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) __attribute__ ((__nothrow__ ));





 extern _Float32x acoshf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __acoshf32x (_Float32x __x) __attribute__ ((__nothrow__ ));

 extern _Float32x asinhf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __asinhf32x (_Float32x __x) __attribute__ ((__nothrow__ ));

 extern _Float32x atanhf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __atanhf32x (_Float32x __x) __attribute__ ((__nothrow__ ));





 extern _Float32x expf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __expf32x (_Float32x __x) __attribute__ ((__nothrow__ ));


extern _Float32x frexpf32x (_Float32x __x, int *__exponent) __attribute__ ((__nothrow__ )); extern _Float32x __frexpf32x (_Float32x __x, int *__exponent) __attribute__ ((__nothrow__ ));


extern _Float32x ldexpf32x (_Float32x __x, int __exponent) __attribute__ ((__nothrow__ )); extern _Float32x __ldexpf32x (_Float32x __x, int __exponent) __attribute__ ((__nothrow__ ));


 extern _Float32x logf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __logf32x (_Float32x __x) __attribute__ ((__nothrow__ ));


 extern _Float32x log10f32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __log10f32x (_Float32x __x) __attribute__ ((__nothrow__ ));


extern _Float32x modff32x (_Float32x __x, _Float32x *__iptr) __attribute__ ((__nothrow__ )); extern _Float32x __modff32x (_Float32x __x, _Float32x *__iptr) __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (2)));



 extern _Float32x exp10f32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __exp10f32x (_Float32x __x) __attribute__ ((__nothrow__ ));




 extern _Float32x expm1f32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __expm1f32x (_Float32x __x) __attribute__ ((__nothrow__ ));


 extern _Float32x log1pf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __log1pf32x (_Float32x __x) __attribute__ ((__nothrow__ ));


extern _Float32x logbf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __logbf32x (_Float32x __x) __attribute__ ((__nothrow__ ));




 extern _Float32x exp2f32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __exp2f32x (_Float32x __x) __attribute__ ((__nothrow__ ));


 extern _Float32x log2f32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __log2f32x (_Float32x __x) __attribute__ ((__nothrow__ ));






 extern _Float32x powf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )); extern _Float32x __powf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ ));


extern _Float32x sqrtf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __sqrtf32x (_Float32x __x) __attribute__ ((__nothrow__ ));



 extern _Float32x hypotf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )); extern _Float32x __hypotf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ ));




 extern _Float32x cbrtf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __cbrtf32x (_Float32x __x) __attribute__ ((__nothrow__ ));






extern _Float32x ceilf32x (_Float32x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32x __ceilf32x (_Float32x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32x fabsf32x (_Float32x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32x __fabsf32x (_Float32x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32x floorf32x (_Float32x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32x __floorf32x (_Float32x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32x fmodf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )); extern _Float32x __fmodf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ ));
# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float32x copysignf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32x __copysignf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern _Float32x nanf32x (const char *__tagb) __attribute__ ((__nothrow__ )); extern _Float32x __nanf32x (const char *__tagb) __attribute__ ((__nothrow__ ));
# 220 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float32x j0f32x (_Float32x) __attribute__ ((__nothrow__ )); extern _Float32x __j0f32x (_Float32x) __attribute__ ((__nothrow__ ));
extern _Float32x j1f32x (_Float32x) __attribute__ ((__nothrow__ )); extern _Float32x __j1f32x (_Float32x) __attribute__ ((__nothrow__ ));
extern _Float32x jnf32x (int, _Float32x) __attribute__ ((__nothrow__ )); extern _Float32x __jnf32x (int, _Float32x) __attribute__ ((__nothrow__ ));
extern _Float32x y0f32x (_Float32x) __attribute__ ((__nothrow__ )); extern _Float32x __y0f32x (_Float32x) __attribute__ ((__nothrow__ ));
extern _Float32x y1f32x (_Float32x) __attribute__ ((__nothrow__ )); extern _Float32x __y1f32x (_Float32x) __attribute__ ((__nothrow__ ));
extern _Float32x ynf32x (int, _Float32x) __attribute__ ((__nothrow__ )); extern _Float32x __ynf32x (int, _Float32x) __attribute__ ((__nothrow__ ));





 extern _Float32x erff32x (_Float32x) __attribute__ ((__nothrow__ )); extern _Float32x __erff32x (_Float32x) __attribute__ ((__nothrow__ ));
 extern _Float32x erfcf32x (_Float32x) __attribute__ ((__nothrow__ )); extern _Float32x __erfcf32x (_Float32x) __attribute__ ((__nothrow__ ));
extern _Float32x lgammaf32x (_Float32x) __attribute__ ((__nothrow__ )); extern _Float32x __lgammaf32x (_Float32x) __attribute__ ((__nothrow__ ));




extern _Float32x tgammaf32x (_Float32x) __attribute__ ((__nothrow__ )); extern _Float32x __tgammaf32x (_Float32x) __attribute__ ((__nothrow__ ));
# 252 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float32x lgammaf32x_r (_Float32x, int *__signgamp) __attribute__ ((__nothrow__ )); extern _Float32x __lgammaf32x_r (_Float32x, int *__signgamp) __attribute__ ((__nothrow__ ));






extern _Float32x rintf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __rintf32x (_Float32x __x) __attribute__ ((__nothrow__ ));


extern _Float32x nextafterf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )); extern _Float32x __nextafterf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ ));






extern _Float32x nextdownf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __nextdownf32x (_Float32x __x) __attribute__ ((__nothrow__ ));

extern _Float32x nextupf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __nextupf32x (_Float32x __x) __attribute__ ((__nothrow__ ));



extern _Float32x remainderf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )); extern _Float32x __remainderf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ ));



extern _Float32x scalbnf32x (_Float32x __x, int __n) __attribute__ ((__nothrow__ )); extern _Float32x __scalbnf32x (_Float32x __x, int __n) __attribute__ ((__nothrow__ ));



extern int ilogbf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern int __ilogbf32x (_Float32x __x) __attribute__ ((__nothrow__ ));




extern long int llogbf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern long int __llogbf32x (_Float32x __x) __attribute__ ((__nothrow__ ));




extern _Float32x scalblnf32x (_Float32x __x, long int __n) __attribute__ ((__nothrow__ )); extern _Float32x __scalblnf32x (_Float32x __x, long int __n) __attribute__ ((__nothrow__ ));



extern _Float32x nearbyintf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern _Float32x __nearbyintf32x (_Float32x __x) __attribute__ ((__nothrow__ ));



extern _Float32x roundf32x (_Float32x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32x __roundf32x (_Float32x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));



extern _Float32x truncf32x (_Float32x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32x __truncf32x (_Float32x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern _Float32x remquof32x (_Float32x __x, _Float32x __y, int *__quo) __attribute__ ((__nothrow__ )); extern _Float32x __remquof32x (_Float32x __x, _Float32x __y, int *__quo) __attribute__ ((__nothrow__ ));






extern long int lrintf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern long int __lrintf32x (_Float32x __x) __attribute__ ((__nothrow__ ));
__extension__
extern long long int llrintf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern long long int __llrintf32x (_Float32x __x) __attribute__ ((__nothrow__ ));



extern long int lroundf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern long int __lroundf32x (_Float32x __x) __attribute__ ((__nothrow__ ));
__extension__
extern long long int llroundf32x (_Float32x __x) __attribute__ ((__nothrow__ )); extern long long int __llroundf32x (_Float32x __x) __attribute__ ((__nothrow__ ));



extern _Float32x fdimf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )); extern _Float32x __fdimf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ ));



extern _Float32x fmaxf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32x __fmaxf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32x fminf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32x __fminf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));



extern _Float32x fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) __attribute__ ((__nothrow__ )); extern _Float32x __fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) __attribute__ ((__nothrow__ ));




extern _Float32x roundevenf32x (_Float32x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32x __roundevenf32x (_Float32x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));



extern __intmax_t fromfpf32x (_Float32x __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __intmax_t __fromfpf32x (_Float32x __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));




extern __uintmax_t ufromfpf32x (_Float32x __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __uintmax_t __ufromfpf32x (_Float32x __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));





extern __intmax_t fromfpxf32x (_Float32x __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __intmax_t __fromfpxf32x (_Float32x __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));





extern __uintmax_t ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __uintmax_t __ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));



extern int canonicalizef32x (_Float32x *__cx, const _Float32x *__x) __attribute__ ((__nothrow__ ));






extern _Float32x fmaxmagf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32x __fmaxmagf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32x fminmagf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32x __fminmagf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern _Float32x fmaximumf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32x __fmaximumf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32x fminimumf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32x __fminimumf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32x fmaximum_numf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32x __fmaximum_numf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32x fminimum_numf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32x __fminimum_numf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32x fmaximum_magf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32x __fmaximum_magf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32x fminimum_magf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32x __fminimum_magf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32x fmaximum_mag_numf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32x __fmaximum_mag_numf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float32x fminimum_mag_numf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float32x __fminimum_mag_numf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern int totalorderf32x (const _Float32x *__x, const _Float32x *__y) __attribute__ ((__nothrow__ ))

     __attribute__ ((__pure__));


extern int totalordermagf32x (const _Float32x *__x, const _Float32x *__y) __attribute__ ((__nothrow__ ))

     __attribute__ ((__pure__));


extern _Float32x getpayloadf32x (const _Float32x *__x) __attribute__ ((__nothrow__ )); extern _Float32x __getpayloadf32x (const _Float32x *__x) __attribute__ ((__nothrow__ ));


extern int setpayloadf32x (_Float32x *__x, _Float32x __payload) __attribute__ ((__nothrow__ ));


extern int setpayloadsigf32x (_Float32x *__x, _Float32x __payload) __attribute__ ((__nothrow__ ));
# 502 "/usr/include/math.h" 2 3 4
# 518 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
 extern _Float64x acosf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __acosf64x (_Float64x __x) __attribute__ ((__nothrow__ ));

 extern _Float64x asinf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __asinf64x (_Float64x __x) __attribute__ ((__nothrow__ ));

 extern _Float64x atanf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __atanf64x (_Float64x __x) __attribute__ ((__nothrow__ ));

 extern _Float64x atan2f64x (_Float64x __y, _Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __atan2f64x (_Float64x __y, _Float64x __x) __attribute__ ((__nothrow__ ));


 extern _Float64x cosf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __cosf64x (_Float64x __x) __attribute__ ((__nothrow__ ));

 extern _Float64x sinf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __sinf64x (_Float64x __x) __attribute__ ((__nothrow__ ));

 extern _Float64x tanf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __tanf64x (_Float64x __x) __attribute__ ((__nothrow__ ));




 extern _Float64x coshf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __coshf64x (_Float64x __x) __attribute__ ((__nothrow__ ));

 extern _Float64x sinhf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __sinhf64x (_Float64x __x) __attribute__ ((__nothrow__ ));

 extern _Float64x tanhf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __tanhf64x (_Float64x __x) __attribute__ ((__nothrow__ ));



 extern void sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) __attribute__ ((__nothrow__ )); extern void __sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) __attribute__ ((__nothrow__ ));





 extern _Float64x acoshf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __acoshf64x (_Float64x __x) __attribute__ ((__nothrow__ ));

 extern _Float64x asinhf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __asinhf64x (_Float64x __x) __attribute__ ((__nothrow__ ));

 extern _Float64x atanhf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __atanhf64x (_Float64x __x) __attribute__ ((__nothrow__ ));





 extern _Float64x expf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __expf64x (_Float64x __x) __attribute__ ((__nothrow__ ));


extern _Float64x frexpf64x (_Float64x __x, int *__exponent) __attribute__ ((__nothrow__ )); extern _Float64x __frexpf64x (_Float64x __x, int *__exponent) __attribute__ ((__nothrow__ ));


extern _Float64x ldexpf64x (_Float64x __x, int __exponent) __attribute__ ((__nothrow__ )); extern _Float64x __ldexpf64x (_Float64x __x, int __exponent) __attribute__ ((__nothrow__ ));


 extern _Float64x logf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __logf64x (_Float64x __x) __attribute__ ((__nothrow__ ));


 extern _Float64x log10f64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __log10f64x (_Float64x __x) __attribute__ ((__nothrow__ ));


extern _Float64x modff64x (_Float64x __x, _Float64x *__iptr) __attribute__ ((__nothrow__ )); extern _Float64x __modff64x (_Float64x __x, _Float64x *__iptr) __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (2)));



 extern _Float64x exp10f64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __exp10f64x (_Float64x __x) __attribute__ ((__nothrow__ ));




 extern _Float64x expm1f64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __expm1f64x (_Float64x __x) __attribute__ ((__nothrow__ ));


 extern _Float64x log1pf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __log1pf64x (_Float64x __x) __attribute__ ((__nothrow__ ));


extern _Float64x logbf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __logbf64x (_Float64x __x) __attribute__ ((__nothrow__ ));




 extern _Float64x exp2f64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __exp2f64x (_Float64x __x) __attribute__ ((__nothrow__ ));


 extern _Float64x log2f64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __log2f64x (_Float64x __x) __attribute__ ((__nothrow__ ));






 extern _Float64x powf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )); extern _Float64x __powf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ ));


extern _Float64x sqrtf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __sqrtf64x (_Float64x __x) __attribute__ ((__nothrow__ ));



 extern _Float64x hypotf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )); extern _Float64x __hypotf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ ));




 extern _Float64x cbrtf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __cbrtf64x (_Float64x __x) __attribute__ ((__nothrow__ ));






extern _Float64x ceilf64x (_Float64x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64x __ceilf64x (_Float64x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64x fabsf64x (_Float64x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64x __fabsf64x (_Float64x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64x floorf64x (_Float64x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64x __floorf64x (_Float64x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64x fmodf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )); extern _Float64x __fmodf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ ));
# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float64x copysignf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64x __copysignf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern _Float64x nanf64x (const char *__tagb) __attribute__ ((__nothrow__ )); extern _Float64x __nanf64x (const char *__tagb) __attribute__ ((__nothrow__ ));
# 220 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float64x j0f64x (_Float64x) __attribute__ ((__nothrow__ )); extern _Float64x __j0f64x (_Float64x) __attribute__ ((__nothrow__ ));
extern _Float64x j1f64x (_Float64x) __attribute__ ((__nothrow__ )); extern _Float64x __j1f64x (_Float64x) __attribute__ ((__nothrow__ ));
extern _Float64x jnf64x (int, _Float64x) __attribute__ ((__nothrow__ )); extern _Float64x __jnf64x (int, _Float64x) __attribute__ ((__nothrow__ ));
extern _Float64x y0f64x (_Float64x) __attribute__ ((__nothrow__ )); extern _Float64x __y0f64x (_Float64x) __attribute__ ((__nothrow__ ));
extern _Float64x y1f64x (_Float64x) __attribute__ ((__nothrow__ )); extern _Float64x __y1f64x (_Float64x) __attribute__ ((__nothrow__ ));
extern _Float64x ynf64x (int, _Float64x) __attribute__ ((__nothrow__ )); extern _Float64x __ynf64x (int, _Float64x) __attribute__ ((__nothrow__ ));





 extern _Float64x erff64x (_Float64x) __attribute__ ((__nothrow__ )); extern _Float64x __erff64x (_Float64x) __attribute__ ((__nothrow__ ));
 extern _Float64x erfcf64x (_Float64x) __attribute__ ((__nothrow__ )); extern _Float64x __erfcf64x (_Float64x) __attribute__ ((__nothrow__ ));
extern _Float64x lgammaf64x (_Float64x) __attribute__ ((__nothrow__ )); extern _Float64x __lgammaf64x (_Float64x) __attribute__ ((__nothrow__ ));




extern _Float64x tgammaf64x (_Float64x) __attribute__ ((__nothrow__ )); extern _Float64x __tgammaf64x (_Float64x) __attribute__ ((__nothrow__ ));
# 252 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern _Float64x lgammaf64x_r (_Float64x, int *__signgamp) __attribute__ ((__nothrow__ )); extern _Float64x __lgammaf64x_r (_Float64x, int *__signgamp) __attribute__ ((__nothrow__ ));






extern _Float64x rintf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __rintf64x (_Float64x __x) __attribute__ ((__nothrow__ ));


extern _Float64x nextafterf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )); extern _Float64x __nextafterf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ ));






extern _Float64x nextdownf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __nextdownf64x (_Float64x __x) __attribute__ ((__nothrow__ ));

extern _Float64x nextupf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __nextupf64x (_Float64x __x) __attribute__ ((__nothrow__ ));



extern _Float64x remainderf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )); extern _Float64x __remainderf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ ));



extern _Float64x scalbnf64x (_Float64x __x, int __n) __attribute__ ((__nothrow__ )); extern _Float64x __scalbnf64x (_Float64x __x, int __n) __attribute__ ((__nothrow__ ));



extern int ilogbf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern int __ilogbf64x (_Float64x __x) __attribute__ ((__nothrow__ ));




extern long int llogbf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern long int __llogbf64x (_Float64x __x) __attribute__ ((__nothrow__ ));




extern _Float64x scalblnf64x (_Float64x __x, long int __n) __attribute__ ((__nothrow__ )); extern _Float64x __scalblnf64x (_Float64x __x, long int __n) __attribute__ ((__nothrow__ ));



extern _Float64x nearbyintf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern _Float64x __nearbyintf64x (_Float64x __x) __attribute__ ((__nothrow__ ));



extern _Float64x roundf64x (_Float64x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64x __roundf64x (_Float64x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));



extern _Float64x truncf64x (_Float64x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64x __truncf64x (_Float64x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern _Float64x remquof64x (_Float64x __x, _Float64x __y, int *__quo) __attribute__ ((__nothrow__ )); extern _Float64x __remquof64x (_Float64x __x, _Float64x __y, int *__quo) __attribute__ ((__nothrow__ ));






extern long int lrintf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern long int __lrintf64x (_Float64x __x) __attribute__ ((__nothrow__ ));
__extension__
extern long long int llrintf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern long long int __llrintf64x (_Float64x __x) __attribute__ ((__nothrow__ ));



extern long int lroundf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern long int __lroundf64x (_Float64x __x) __attribute__ ((__nothrow__ ));
__extension__
extern long long int llroundf64x (_Float64x __x) __attribute__ ((__nothrow__ )); extern long long int __llroundf64x (_Float64x __x) __attribute__ ((__nothrow__ ));



extern _Float64x fdimf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )); extern _Float64x __fdimf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ ));



extern _Float64x fmaxf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64x __fmaxf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64x fminf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64x __fminf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));



extern _Float64x fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) __attribute__ ((__nothrow__ )); extern _Float64x __fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) __attribute__ ((__nothrow__ ));




extern _Float64x roundevenf64x (_Float64x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64x __roundevenf64x (_Float64x __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));



extern __intmax_t fromfpf64x (_Float64x __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __intmax_t __fromfpf64x (_Float64x __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));




extern __uintmax_t ufromfpf64x (_Float64x __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __uintmax_t __ufromfpf64x (_Float64x __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));





extern __intmax_t fromfpxf64x (_Float64x __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __intmax_t __fromfpxf64x (_Float64x __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));





extern __uintmax_t ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ )); extern __uintmax_t __ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) __attribute__ ((__nothrow__ ));



extern int canonicalizef64x (_Float64x *__cx, const _Float64x *__x) __attribute__ ((__nothrow__ ));






extern _Float64x fmaxmagf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64x __fmaxmagf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64x fminmagf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64x __fminmagf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern _Float64x fmaximumf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64x __fmaximumf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64x fminimumf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64x __fminimumf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64x fmaximum_numf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64x __fmaximum_numf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64x fminimum_numf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64x __fminimum_numf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64x fmaximum_magf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64x __fmaximum_magf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64x fminimum_magf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64x __fminimum_magf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64x fmaximum_mag_numf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64x __fmaximum_mag_numf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern _Float64x fminimum_mag_numf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)); extern _Float64x __fminimum_mag_numf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));




extern int totalorderf64x (const _Float64x *__x, const _Float64x *__y) __attribute__ ((__nothrow__ ))

     __attribute__ ((__pure__));


extern int totalordermagf64x (const _Float64x *__x, const _Float64x *__y) __attribute__ ((__nothrow__ ))

     __attribute__ ((__pure__));


extern _Float64x getpayloadf64x (const _Float64x *__x) __attribute__ ((__nothrow__ )); extern _Float64x __getpayloadf64x (const _Float64x *__x) __attribute__ ((__nothrow__ ));


extern int setpayloadf64x (_Float64x *__x, _Float64x __payload) __attribute__ ((__nothrow__ ));


extern int setpayloadsigf64x (_Float64x *__x, _Float64x __payload) __attribute__ ((__nothrow__ ));
# 519 "/usr/include/math.h" 2 3 4
# 566 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4
extern float fadd (double __x, double __y) __attribute__ ((__nothrow__ ));


extern float fdiv (double __x, double __y) __attribute__ ((__nothrow__ ));


extern float ffma (double __x, double __y, double __z) __attribute__ ((__nothrow__ ));


extern float fmul (double __x, double __y) __attribute__ ((__nothrow__ ));


extern float fsqrt (double __x) __attribute__ ((__nothrow__ ));


extern float fsub (double __x, double __y) __attribute__ ((__nothrow__ ));
# 567 "/usr/include/math.h" 2 3 4
# 587 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4
extern float faddl (long double __x, long double __y) __attribute__ ((__nothrow__ ));


extern float fdivl (long double __x, long double __y) __attribute__ ((__nothrow__ ));


extern float ffmal (long double __x, long double __y, long double __z) __attribute__ ((__nothrow__ ));


extern float fmull (long double __x, long double __y) __attribute__ ((__nothrow__ ));


extern float fsqrtl (long double __x) __attribute__ ((__nothrow__ ));


extern float fsubl (long double __x, long double __y) __attribute__ ((__nothrow__ ));
# 588 "/usr/include/math.h" 2 3 4
# 616 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4
extern double daddl (long double __x, long double __y) __attribute__ ((__nothrow__ ));


extern double ddivl (long double __x, long double __y) __attribute__ ((__nothrow__ ));


extern double dfmal (long double __x, long double __y, long double __z) __attribute__ ((__nothrow__ ));


extern double dmull (long double __x, long double __y) __attribute__ ((__nothrow__ ));


extern double dsqrtl (long double __x) __attribute__ ((__nothrow__ ));


extern double dsubl (long double __x, long double __y) __attribute__ ((__nothrow__ ));
# 617 "/usr/include/math.h" 2 3 4
# 697 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4
extern _Float32 f32addf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ ));


extern _Float32 f32divf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ ));


extern _Float32 f32fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) __attribute__ ((__nothrow__ ));


extern _Float32 f32mulf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ ));


extern _Float32 f32sqrtf32x (_Float32x __x) __attribute__ ((__nothrow__ ));


extern _Float32 f32subf32x (_Float32x __x, _Float32x __y) __attribute__ ((__nothrow__ ));
# 698 "/usr/include/math.h" 2 3 4
# 707 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4
extern _Float32 f32addf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ ));


extern _Float32 f32divf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ ));


extern _Float32 f32fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) __attribute__ ((__nothrow__ ));


extern _Float32 f32mulf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ ));


extern _Float32 f32sqrtf64 (_Float64 __x) __attribute__ ((__nothrow__ ));


extern _Float32 f32subf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ ));
# 708 "/usr/include/math.h" 2 3 4
# 717 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4
extern _Float32 f32addf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ ));


extern _Float32 f32divf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ ));


extern _Float32 f32fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) __attribute__ ((__nothrow__ ));


extern _Float32 f32mulf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ ));


extern _Float32 f32sqrtf64x (_Float64x __x) __attribute__ ((__nothrow__ ));


extern _Float32 f32subf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ ));
# 718 "/usr/include/math.h" 2 3 4
# 747 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4
extern _Float32x f32xaddf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ ));


extern _Float32x f32xdivf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ ));


extern _Float32x f32xfmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) __attribute__ ((__nothrow__ ));


extern _Float32x f32xmulf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ ));


extern _Float32x f32xsqrtf64 (_Float64 __x) __attribute__ ((__nothrow__ ));


extern _Float32x f32xsubf64 (_Float64 __x, _Float64 __y) __attribute__ ((__nothrow__ ));
# 748 "/usr/include/math.h" 2 3 4
# 757 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4
extern _Float32x f32xaddf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ ));


extern _Float32x f32xdivf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ ));


extern _Float32x f32xfmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) __attribute__ ((__nothrow__ ));


extern _Float32x f32xmulf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ ));


extern _Float32x f32xsqrtf64x (_Float64x __x) __attribute__ ((__nothrow__ ));


extern _Float32x f32xsubf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ ));
# 758 "/usr/include/math.h" 2 3 4
# 787 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4
extern _Float64 f64addf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ ));


extern _Float64 f64divf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ ));


extern _Float64 f64fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) __attribute__ ((__nothrow__ ));


extern _Float64 f64mulf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ ));


extern _Float64 f64sqrtf64x (_Float64x __x) __attribute__ ((__nothrow__ ));


extern _Float64 f64subf64x (_Float64x __x, _Float64x __y) __attribute__ ((__nothrow__ ));
# 788 "/usr/include/math.h" 2 3 4
# 854 "/usr/include/math.h" 3 4
extern int signgam;
# 934 "/usr/include/math.h" 3 4
enum
  {
    FP_NAN =

      0,
    FP_INFINITE =

      1,
    FP_ZERO =

      2,
    FP_SUBNORMAL =

      3,
    FP_NORMAL =

      4
  };
# 1055 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/iscanonical.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/iscanonical.h" 3 4
extern int __iscanonicall (long double __x)
     __attribute__ ((__nothrow__ )) __attribute__ ((__const__));
# 1056 "/usr/include/math.h" 2 3 4
# 31 "./ajla.h" 2




# 1 "/usr/include/stdlib.h" 1 3 4
# 26 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 27 "/usr/include/stdlib.h" 2 3 4





# 1 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 1 3 4
# 93 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 3 4
# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_size_t.h" 1 3 4
# 94 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3 4
# 103 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 3 4
# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_wchar_t.h" 1 3 4
# 104 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3 4




# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_null.h" 1 3 4
# 109 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3 4
# 33 "/usr/include/stdlib.h" 2 3 4







# 1 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 1 3 4
# 41 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" 1 3 4
# 42 "/usr/include/stdlib.h" 2 3 4
# 59 "/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;
# 98 "/usr/include/stdlib.h" 3 4
extern size_t __ctype_get_mb_cur_max (void) __attribute__ ((__nothrow__ )) ;



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

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

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



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



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



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

extern long double strtold (const char *__restrict __nptr,
       char **__restrict __endptr)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));
# 141 "/usr/include/stdlib.h" 3 4
extern _Float32 strtof32 (const char *__restrict __nptr,
     char **__restrict __endptr)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));



extern _Float64 strtof64 (const char *__restrict __nptr,
     char **__restrict __endptr)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));
# 159 "/usr/include/stdlib.h" 3 4
extern _Float32x strtof32x (const char *__restrict __nptr,
       char **__restrict __endptr)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));



extern _Float64x strtof64x (const char *__restrict __nptr,
       char **__restrict __endptr)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));
# 177 "/usr/include/stdlib.h" 3 4
extern long int strtol (const char *__restrict __nptr,
   char **__restrict __endptr, int __base)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));

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



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

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




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

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






extern long int strtol (const char *__restrict __nptr, char **__restrict __endptr, int __base) __asm__ ("" "__isoc23_strtol") __attribute__ ((__nothrow__ ))


     __attribute__ ((__nonnull__ (1)));
extern unsigned long int strtoul (const char *__restrict __nptr, char **__restrict __endptr, int __base) __asm__ ("" "__isoc23_strtoul") __attribute__ ((__nothrow__ ))



     __attribute__ ((__nonnull__ (1)));

__extension__
extern long long int strtoq (const char *__restrict __nptr, char **__restrict __endptr, int __base) __asm__ ("" "__isoc23_strtoll") __attribute__ ((__nothrow__ ))


     __attribute__ ((__nonnull__ (1)));
__extension__
extern unsigned long long int strtouq (const char *__restrict __nptr, char **__restrict __endptr, int __base) __asm__ ("" "__isoc23_strtoull") __attribute__ ((__nothrow__ ))



     __attribute__ ((__nonnull__ (1)));

__extension__
extern long long int strtoll (const char *__restrict __nptr, char **__restrict __endptr, int __base) __asm__ ("" "__isoc23_strtoll") __attribute__ ((__nothrow__ ))


     __attribute__ ((__nonnull__ (1)));
__extension__
extern unsigned long long int strtoull (const char *__restrict __nptr, char **__restrict __endptr, int __base) __asm__ ("" "__isoc23_strtoull") __attribute__ ((__nothrow__ ))



     __attribute__ ((__nonnull__ (1)));
# 278 "/usr/include/stdlib.h" 3 4
extern int strfromd (char *__dest, size_t __size, const char *__format,
       double __f)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (3)));

extern int strfromf (char *__dest, size_t __size, const char *__format,
       float __f)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (3)));

extern int strfroml (char *__dest, size_t __size, const char *__format,
       long double __f)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (3)));
# 298 "/usr/include/stdlib.h" 3 4
extern int strfromf32 (char *__dest, size_t __size, const char * __format,
         _Float32 __f)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (3)));



extern int strfromf64 (char *__dest, size_t __size, const char * __format,
         _Float64 __f)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (3)));
# 316 "/usr/include/stdlib.h" 3 4
extern int strfromf32x (char *__dest, size_t __size, const char * __format,
   _Float32x __f)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (3)));



extern int strfromf64x (char *__dest, size_t __size, const char * __format,
   _Float64x __f)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (3)));
# 338 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h" 3 4
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];
};

typedef struct __locale_struct *__locale_t;
# 23 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 2 3 4

typedef __locale_t locale_t;
# 339 "/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)));

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

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

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





extern long int strtol_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) __asm__ ("" "__isoc23_strtol_l") __attribute__ ((__nothrow__ ))



     __attribute__ ((__nonnull__ (1, 4)));
extern unsigned long int strtoul_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) __asm__ ("" "__isoc23_strtoul_l") __attribute__ ((__nothrow__ ))




     __attribute__ ((__nonnull__ (1, 4)));
__extension__
extern long long int strtoll_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) __asm__ ("" "__isoc23_strtoll_l") __attribute__ ((__nothrow__ ))




     __attribute__ ((__nonnull__ (1, 4)));
__extension__
extern unsigned long long int strtoull_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) __asm__ ("" "__isoc23_strtoull_l") __attribute__ ((__nothrow__ ))




     __attribute__ ((__nonnull__ (1, 4)));
# 415 "/usr/include/stdlib.h" 3 4
extern double strtod_l (const char *__restrict __nptr,
   char **__restrict __endptr, locale_t __loc)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 3)));

extern float strtof_l (const char *__restrict __nptr,
         char **__restrict __endptr, locale_t __loc)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 3)));

extern long double strtold_l (const char *__restrict __nptr,
         char **__restrict __endptr,
         locale_t __loc)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 3)));
# 436 "/usr/include/stdlib.h" 3 4
extern _Float32 strtof32_l (const char *__restrict __nptr,
       char **__restrict __endptr,
       locale_t __loc)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 3)));



extern _Float64 strtof64_l (const char *__restrict __nptr,
       char **__restrict __endptr,
       locale_t __loc)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 3)));
# 457 "/usr/include/stdlib.h" 3 4
extern _Float32x strtof32x_l (const char *__restrict __nptr,
         char **__restrict __endptr,
         locale_t __loc)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 3)));



extern _Float64x strtof64x_l (const char *__restrict __nptr,
         char **__restrict __endptr,
         locale_t __loc)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 3)));
# 480 "/usr/include/stdlib.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__nothrow__ )) atoi (const char *__nptr)
{
  return (int) strtol (__nptr, (char **) ((void*)0), 10);
}
extern __inline __attribute__ ((__gnu_inline__)) long int
__attribute__ ((__nothrow__ )) atol (const char *__nptr)
{
  return strtol (__nptr, (char **) ((void*)0), 10);
}


__extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int
__attribute__ ((__nothrow__ )) atoll (const char *__nptr)
{
  return strtoll (__nptr, (char **) ((void*)0), 10);
}
# 505 "/usr/include/stdlib.h" 3 4
extern char *l64a (long int __n) __attribute__ ((__nothrow__ )) ;


extern long int a64l (const char *__s)
     __attribute__ ((__nothrow__ )) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
# 521 "/usr/include/stdlib.h" 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;
    __extension__ 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 __uint32_t arc4random (void)
     __attribute__ ((__nothrow__ )) ;


extern void arc4random_buf (void *__buf, size_t __size)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));



extern __uint32_t arc4random_uniform (__uint32_t __upper_bound)
     __attribute__ ((__nothrow__ )) ;




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

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






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


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







extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size)
     __attribute__ ((__nothrow__ )) __attribute__ ((__warn_unused_result__))

                       ;


extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size)
     __attribute__ ((__nothrow__ )) ;



# 1 "/usr/include/alloca.h" 1 3 4
# 24 "/usr/include/alloca.h" 3 4
# 1 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 1 3 4
# 93 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 3 4
# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_size_t.h" 1 3 4
# 94 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3 4
# 25 "/usr/include/alloca.h" 2 3 4







extern void *alloca (size_t __size) __attribute__ ((__nothrow__ ));
# 707 "/usr/include/stdlib.h" 2 3 4





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




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




extern void *aligned_alloc (size_t __alignment, size_t __size)
     __attribute__ ((__nothrow__ )) __attribute__ ((__malloc__)) __attribute__ ((__alloc_align__ (1)))
                                         ;



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



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







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




extern char *secure_getenv (const char *__name)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1))) ;






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__ ));
# 814 "/usr/include/stdlib.h" 3 4
extern char *mktemp (char *__template) __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));
# 830 "/usr/include/stdlib.h" 3 4
extern int mkstemp (char *__template) __asm__ ("" "mkstemp64")
     __attribute__ ((__nonnull__ (1))) ;





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






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





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

     __attribute__ ((__nonnull__ (1))) ;





extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
     __attribute__ ((__nonnull__ (1))) ;
# 923 "/usr/include/stdlib.h" 3 4
extern int system (const char *__command) ;





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






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


# 1 "/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h" 1 3 4
# 19 "/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) void *
bsearch (const void *__key, const void *__base, size_t __nmemb, size_t __size,
  __compar_fn_t __compar)
{
  size_t __l, __u, __idx;
  const void *__p;
  int __comparison;

  __l = 0;
  __u = __nmemb;
  while (__l < __u)
    {
      __idx = (__l + __u) / 2;
      __p = (const void *) (((const char *) __base) + (__idx * __size));
      __comparison = (*__compar) (__key, __p);
      if (__comparison < 0)
 __u = __idx;
      else if (__comparison > 0)
 __l = __idx + 1;
      else
 {




   return (void *) __p;



 }
    }

  return ((void*)0);
}
# 966 "/usr/include/stdlib.h" 2 3 4




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__)) ;
extern long int labs (long int __x) __attribute__ ((__nothrow__ )) __attribute__ ((__const__)) ;


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






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


__extension__ extern lldiv_t lldiv (long long int __numer,
        long long int __denom)
     __attribute__ ((__nothrow__ )) __attribute__ ((__const__)) ;
# 1012 "/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))) ;




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




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




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




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


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


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



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))) ;
# 1099 "/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))) ;







extern int posix_openpt (int __oflag) ;







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



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




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






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)));
# 1155 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/stdlib-float.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/stdlib-float.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) double
__attribute__ ((__nothrow__ )) atof (const char *__nptr)
{
  return strtod (__nptr, (char **) ((void*)0));
}
# 1156 "/usr/include/stdlib.h" 2 3 4
# 36 "./ajla.h" 2


# 1 "/usr/include/string.h" 1 3 4
# 26 "/usr/include/string.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 27 "/usr/include/string.h" 2 3 4






# 1 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 1 3 4
# 93 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 3 4
# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_size_t.h" 1 3 4
# 94 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3 4
# 108 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 3 4
# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_null.h" 1 3 4
# 109 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3 4
# 34 "/usr/include/string.h" 2 3 4
# 43 "/usr/include/string.h" 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)));
# 80 "/usr/include/string.h" 3 4
extern int __memcmpeq (const void *__s1, const void *__s2, size_t __n)
     __attribute__ ((__nothrow__ )) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 107 "/usr/include/string.h" 3 4
extern void *memchr (const void *__s, int __c, size_t __n)
      __attribute__ ((__nothrow__ )) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 120 "/usr/include/string.h" 3 4
extern void *rawmemchr (const void *__s, int __c)
     __attribute__ ((__nothrow__ )) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 133 "/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))) ;






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)));
# 246 "/usr/include/string.h" 3 4
extern char *strchr (const char *__s, int __c)
     __attribute__ ((__nothrow__ )) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 273 "/usr/include/string.h" 3 4
extern char *strrchr (const char *__s, int __c)
     __attribute__ ((__nothrow__ )) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 286 "/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)));
# 323 "/usr/include/string.h" 3 4
extern char *strpbrk (const char *__s, const char *__accept)
     __attribute__ ((__nothrow__ )) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 350 "/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)));
# 380 "/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__ ));
# 444 "/usr/include/string.h" 3 4
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (2))) ;




extern const char *strerrordesc_np (int __err) __attribute__ ((__nothrow__ ));

extern const char *strerrorname_np (int __err) __attribute__ ((__nothrow__ ));





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



# 1 "/usr/include/strings.h" 1 3 4
# 23 "/usr/include/strings.h" 3 4
# 1 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 1 3 4
# 93 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 3 4
# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_size_t.h" 1 3 4
# 94 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3 4
# 24 "/usr/include/strings.h" 2 3 4
# 34 "/usr/include/strings.h" 3 4
extern int bcmp (const void *__s1, const void *__s2, size_t __n)
     __attribute__ ((__nothrow__ )) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


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)));
# 68 "/usr/include/strings.h" 3 4
extern char *index (const char *__s, int __c)
     __attribute__ ((__nothrow__ )) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 96 "/usr/include/strings.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)));
# 463 "/usr/include/string.h" 2 3 4



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



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




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



extern const char *sigabbrev_np (int __sig) __attribute__ ((__nothrow__ ));


extern const char *sigdescr_np (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 size_t strlcpy (char *__restrict __dest,
         const char *__restrict __src, size_t __n)
  __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 2))) ;



extern size_t strlcat (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)))
                                          ;
# 540 "/usr/include/string.h" 3 4
extern char *basename (const char *__filename) __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));
# 39 "./ajla.h" 2




# 1 "/usr/include/errno.h" 1 3 4
# 28 "/usr/include/errno.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/errno.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/bits/errno.h" 3 4
# 1 "/usr/include/linux/errno.h" 1 3 4
# 1 "/usr/include/x86_64-linux-gnu/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
# 6 "/usr/include/asm-generic/errno.h" 2 3 4
# 2 "/usr/include/x86_64-linux-gnu/asm/errno.h" 2 3 4
# 2 "/usr/include/linux/errno.h" 2 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/errno.h" 2 3 4
# 29 "/usr/include/errno.h" 2 3 4








extern int *__errno_location (void) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));







extern char *program_invocation_name;
extern char *program_invocation_short_name;

# 1 "/usr/include/x86_64-linux-gnu/bits/types/error_t.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/types/error_t.h" 3 4
typedef int error_t;
# 49 "/usr/include/errno.h" 2 3 4
# 44 "./ajla.h" 2

# 1 "./debug.h" 1
# 46 "./ajla.h" 2
# 1 "./cfg.h" 1
# 47 "./ajla.h" 2
# 1 "./compiler.h" 1
# 21 "./compiler.h"
# 1 "/usr/lib/llvm-20/lib/clang/20/include/stdint.h" 1 3
# 56 "/usr/lib/llvm-20/lib/clang/20/include/stdint.h" 3
# 1 "/usr/include/stdint.h" 1 3 4
# 26 "/usr/include/stdint.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 27 "/usr/include/stdint.h" 2 3 4

# 1 "/usr/include/x86_64-linux-gnu/bits/wchar.h" 1 3 4
# 29 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 30 "/usr/include/stdint.h" 2 3 4







# 1 "/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h" 3 4
typedef __uint8_t uint8_t;
typedef __uint16_t uint16_t;
typedef __uint32_t uint32_t;
typedef __uint64_t uint64_t;
# 38 "/usr/include/stdint.h" 2 3 4



# 1 "/usr/include/x86_64-linux-gnu/bits/stdint-least.h" 1 3 4
# 25 "/usr/include/x86_64-linux-gnu/bits/stdint-least.h" 3 4
typedef __int_least8_t int_least8_t;
typedef __int_least16_t int_least16_t;
typedef __int_least32_t int_least32_t;
typedef __int_least64_t int_least64_t;


typedef __uint_least8_t uint_least8_t;
typedef __uint_least16_t uint_least16_t;
typedef __uint_least32_t uint_least32_t;
typedef __uint_least64_t uint_least64_t;
# 42 "/usr/include/stdint.h" 2 3 4





typedef signed char int_fast8_t;

typedef long int int_fast16_t;
typedef long int int_fast32_t;
typedef long int int_fast64_t;
# 60 "/usr/include/stdint.h" 3 4
typedef unsigned char uint_fast8_t;

typedef unsigned long int uint_fast16_t;
typedef unsigned long int uint_fast32_t;
typedef unsigned long int uint_fast64_t;
# 76 "/usr/include/stdint.h" 3 4
typedef long int intptr_t;


typedef unsigned long int uintptr_t;
# 90 "/usr/include/stdint.h" 3 4
typedef __intmax_t intmax_t;
typedef __uintmax_t uintmax_t;
# 57 "/usr/lib/llvm-20/lib/clang/20/include/stdint.h" 2 3
# 22 "./compiler.h" 2

# 1 "/usr/lib/llvm-20/lib/clang/20/include/inttypes.h" 1 3
# 24 "/usr/lib/llvm-20/lib/clang/20/include/inttypes.h" 3
# 1 "/usr/include/inttypes.h" 1 3 4
# 34 "/usr/include/inttypes.h" 3 4
typedef int __gwchar_t;
# 332 "/usr/include/inttypes.h" 3 4
typedef struct
  {
    long int quot;
    long int rem;
  } imaxdiv_t;
# 351 "/usr/include/inttypes.h" 3 4
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__ ));





extern intmax_t strtoimax (const char *__restrict __nptr, char **__restrict __endptr, int __base) __asm__ ("" "__isoc23_strtoimax") __attribute__ ((__nothrow__ ));


extern uintmax_t strtoumax (const char *__restrict __nptr, char **__restrict __endptr, int __base) __asm__ ("" "__isoc23_strtoumax") __attribute__ ((__nothrow__ ));


extern intmax_t wcstoimax (const __gwchar_t *__restrict __nptr, __gwchar_t **__restrict __endptr, int __base) __asm__ ("" "__isoc23_wcstoimax") __attribute__ ((__nothrow__ ));



extern uintmax_t wcstoumax (const __gwchar_t *__restrict __nptr, __gwchar_t **__restrict __endptr, int __base) __asm__ ("" "__isoc23_wcstoumax") __attribute__ ((__nothrow__ ));
# 25 "/usr/lib/llvm-20/lib/clang/20/include/inttypes.h" 2 3
# 24 "./compiler.h" 2
# 104 "./compiler.h"
typedef __int128 intbig_t;
typedef unsigned __int128 uintbig_t;
# 178 "./compiler.h"
# 1 "/usr/lib/llvm-20/lib/clang/20/include/stdbool.h" 1 3
# 179 "./compiler.h" 2
# 196 "./compiler.h"
# 1 "/usr/lib/llvm-20/lib/clang/20/include/stdatomic.h" 1 3
# 27 "/usr/lib/llvm-20/lib/clang/20/include/stdatomic.h" 3
# 1 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 1 3
# 88 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 3
# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_ptrdiff_t.h" 1 3
# 89 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3




# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_size_t.h" 1 3
# 94 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3
# 103 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 3
# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_wchar_t.h" 1 3
# 104 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3
# 128 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 3
# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_offsetof.h" 1 3
# 129 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3
# 28 "/usr/lib/llvm-20/lib/clang/20/include/stdatomic.h" 2 3
# 68 "/usr/lib/llvm-20/lib/clang/20/include/stdatomic.h" 3
typedef enum memory_order {
  memory_order_relaxed = 0,
  memory_order_consume = 1,
  memory_order_acquire = 2,
  memory_order_release = 3,
  memory_order_acq_rel = 4,
  memory_order_seq_cst = 5
} memory_order;






void atomic_thread_fence(memory_order);
void atomic_signal_fence(memory_order);
# 97 "/usr/lib/llvm-20/lib/clang/20/include/stdatomic.h" 3
typedef _Atomic(_Bool) atomic_bool;

typedef _Atomic(char) atomic_char;
typedef _Atomic(signed char) atomic_schar;
typedef _Atomic(unsigned char) atomic_uchar;
typedef _Atomic(short) atomic_short;
typedef _Atomic(unsigned short) atomic_ushort;
typedef _Atomic(int) atomic_int;
typedef _Atomic(unsigned int) atomic_uint;
typedef _Atomic(long) atomic_long;
typedef _Atomic(unsigned long) atomic_ulong;
typedef _Atomic(long long) atomic_llong;
typedef _Atomic(unsigned long long) atomic_ullong;



typedef _Atomic(uint_least16_t) atomic_char16_t;
typedef _Atomic(uint_least32_t) atomic_char32_t;
typedef _Atomic(wchar_t) atomic_wchar_t;
typedef _Atomic(int_least8_t) atomic_int_least8_t;
typedef _Atomic(uint_least8_t) atomic_uint_least8_t;
typedef _Atomic(int_least16_t) atomic_int_least16_t;
typedef _Atomic(uint_least16_t) atomic_uint_least16_t;
typedef _Atomic(int_least32_t) atomic_int_least32_t;
typedef _Atomic(uint_least32_t) atomic_uint_least32_t;
typedef _Atomic(int_least64_t) atomic_int_least64_t;
typedef _Atomic(uint_least64_t) atomic_uint_least64_t;
typedef _Atomic(int_fast8_t) atomic_int_fast8_t;
typedef _Atomic(uint_fast8_t) atomic_uint_fast8_t;
typedef _Atomic(int_fast16_t) atomic_int_fast16_t;
typedef _Atomic(uint_fast16_t) atomic_uint_fast16_t;
typedef _Atomic(int_fast32_t) atomic_int_fast32_t;
typedef _Atomic(uint_fast32_t) atomic_uint_fast32_t;
typedef _Atomic(int_fast64_t) atomic_int_fast64_t;
typedef _Atomic(uint_fast64_t) atomic_uint_fast64_t;
typedef _Atomic(intptr_t) atomic_intptr_t;
typedef _Atomic(uintptr_t) atomic_uintptr_t;
typedef _Atomic(size_t) atomic_size_t;
typedef _Atomic(ptrdiff_t) atomic_ptrdiff_t;
typedef _Atomic(intmax_t) atomic_intmax_t;
typedef _Atomic(uintmax_t) atomic_uintmax_t;
# 173 "/usr/lib/llvm-20/lib/clang/20/include/stdatomic.h" 3
typedef struct atomic_flag { atomic_bool _Value; } atomic_flag;
# 186 "/usr/lib/llvm-20/lib/clang/20/include/stdatomic.h" 3
_Bool atomic_flag_test_and_set(volatile atomic_flag *);
_Bool atomic_flag_test_and_set_explicit(volatile atomic_flag *, memory_order);

void atomic_flag_clear(volatile atomic_flag *);
void atomic_flag_clear_explicit(volatile atomic_flag *, memory_order);
# 197 "./compiler.h" 2
# 336 "./compiler.h"
# 1 "/usr/lib/llvm-20/lib/clang/20/include/stdnoreturn.h" 1 3
# 337 "./compiler.h" 2
# 431 "./compiler.h"
_Noreturn void not_reached(void);
# 470 "./compiler.h"
static inline __attribute__((__always_inline__)) void *return_ptr(const void *ptr)
{
 return (void *)ptr;
}
# 552 "./compiler.h"
typedef int8_t char_efficient_t;
typedef uint8_t uchar_efficient_t;
typedef int16_t short_efficient_t;
typedef uint16_t ushort_efficient_t;
# 953 "./compiler.h"
static inline void *POINTER_TAG_ADD(void *ptr)
{
 return (void *)((uintptr_t)ptr + ((uintptr_t)1 << 0));
}
static inline void *POINTER_TAG_CLEAR(void *ptr)
{
 return (void *)((uintptr_t)ptr & ~(uintptr_t)((uintptr_t)1 << 0));
}
static inline void *POINTER_TAG_SUB(void *ptr)
{
 return (void *)((uintptr_t)ptr - ((uintptr_t)1 << 0));
}
static inline uintptr_t POINTER_TAG_GET(const void *ptr)
{
 return (uintptr_t)ptr & ((uintptr_t)1 << 0);
}
# 48 "./ajla.h" 2
# 1 "./fn_impl.h" 1
# 49 "./ajla.h" 2
# 1 "./pcode-op.h" 1
# 50 "./ajla.h" 2
# 1 "./fileline.h" 1
# 26 "./fileline.h"
typedef const char * position_t;
# 51 "./ajla.h" 2
# 1 "./error.h" 1
# 37 "./error.h"
typedef struct {
 short error_class;
 short error_type;
 int error_aux;



} ajla_error_t;

const char *error_decode(ajla_error_t);
void trace_v(const char *, va_list);
void trace(const char *, ...) __attribute__((format(printf, 1, 2)));
void stderr_msg_v(const char *m, va_list l);
void stderr_msg(const char *, ...) __attribute__((format(printf, 1, 2)));
void debug_v(const char *, va_list);
void debug(const char *, ...) __attribute__((format(printf, 1, 2)));
void warning_v(const char *, va_list);
void warning(const char *, ...) __attribute__((format(printf, 1, 2)));
_Noreturn void fatal_v(const char *, va_list);
_Noreturn void __attribute__((format(printf, 1, 2))) fatal(const char *, ...);
_Noreturn void internal_v(const char *, const char *, va_list);
_Noreturn void __attribute__((format(printf, 2, 3))) internal(const char *, const char *, ...);



void fatal_mayfail(ajla_error_t, ajla_error_t *, const char *, ...) __attribute__((format(printf, 3, 4)));
void fatal_warning_mayfail(ajla_error_t, ajla_error_t *, const char *, ...) __attribute__((format(printf, 3, 4)));

static inline ajla_error_t error_ajla_aux_(int ec, int type, int aux , const char __attribute__((__unused__)) *position_arg)
{
 ajla_error_t e;
 if ((__builtin_expect((int)(type < 1), 0)) ||
     (__builtin_expect((int)(type >= 35), 0)))
  internal("./error.h" ":" "70", "invalid ajla error type %d", type);
 e.error_class = ec;
 e.error_type = type;
 e.error_aux = aux;




 return e;
}







ajla_error_t error_from_errno(int ec, int errn);

void error_init_multithreaded(void);
void error_done_multithreaded(void);
void error_init(void);
void error_done(void);
# 52 "./ajla.h" 2
# 1 "./options.h" 1
# 25 "./options.h"
typedef signed __int128 int128_t;
typedef unsigned __int128 uint128_t;
# 142 "./options.h"
float half_to_float(uint16_t x);
uint16_t float_to_half(float x);
# 165 "./options.h"
typedef float real32_t;
# 180 "./options.h"
typedef double real64_t;
# 201 "./options.h"
typedef long double real80_t;
# 269 "./options.h"
typedef uint16_t real16_t;
# 406 "./options.h"
typedef uchar_efficient_t ajla_flat_option_t;


typedef int32_t pcode_t;
typedef uint32_t upcode_t;


typedef uint32_t ip_t;
typedef uint32_t frame_t;
typedef uint32_t stack_size_t;

typedef uint32_t arg_t;


typedef frame_t ajla_option_t;
# 53 "./ajla.h" 2
# 1 "./common.h" 1
# 32 "./common.h"
static inline int zero_(void)
{
 return 0;
}
# 53 "./common.h"
static const size_t __attribute__((__unused__)) size_t_limit = (size_t)-1;
# 133 "./common.h"
static inline unsigned low_bit(unsigned x)
{

 return __builtin_ctz(x);
# 149 "./common.h"
}

static inline unsigned high_bit(unsigned x)
{

 return sizeof(unsigned) * 8 - 1 - __builtin_clz(x);
# 165 "./common.h"
}

static inline unsigned log_2(unsigned x)
{
 ((void)(zero_()));
 return low_bit(x);
}

static inline int pop_count(unsigned x)
{

 return __builtin_popcount(x);






}
# 197 "./common.h"
static inline uintptr_t ptr_to_num(const void *ptr)
{
 return (uintptr_t)ptr;
}

static inline void *num_to_ptr(uintptr_t num)
{
 return (void *)num;
}
# 54 "./ajla.h" 2

extern const _Bool dll;
extern int retval;
# 68 "./ajla.h"
extern uchar_efficient_t pointer_compression_enabled;
# 90 "./ajla.h"
void u_codegen_init(void); void c_codegen_init(void); static inline void codegen_init(void) { (pointer_compression_enabled ? c_codegen_init : u_codegen_init)(); }
void u_codegen_done(void); void c_codegen_done(void); static inline void codegen_done(void) { (pointer_compression_enabled ? c_codegen_done : u_codegen_done)(); }
void u_data_init(void); void c_data_init(void); static inline void data_init(void) { (pointer_compression_enabled ? c_data_init : u_data_init)(); }
void u_data_done(void); void c_data_done(void); static inline void data_done(void) { (pointer_compression_enabled ? c_data_done : u_data_done)(); }
void u_array_index_init(void); void c_array_index_init(void); static inline void array_index_init(void) { (pointer_compression_enabled ? c_array_index_init : u_array_index_init)(); }
void u_array_index_done(void); void c_array_index_done(void); static inline void array_index_done(void) { (pointer_compression_enabled ? c_array_index_done : u_array_index_done)(); }
void u_function_init(void); void c_function_init(void); static inline void function_init(void) { (pointer_compression_enabled ? c_function_init : u_function_init)(); }
void u_function_done(void); void c_function_done(void); static inline void function_done(void) { (pointer_compression_enabled ? c_function_done : u_function_done)(); }
void u_pcode_init(void); void c_pcode_init(void); static inline void pcode_init(void) { (pointer_compression_enabled ? c_pcode_init : u_pcode_init)(); }
void u_pcode_done(void); void c_pcode_done(void); static inline void pcode_done(void) { (pointer_compression_enabled ? c_pcode_done : u_pcode_done)(); }
void u_save_init(void); void c_save_init(void); static inline void save_init(void) { (pointer_compression_enabled ? c_save_init : u_save_init)(); }
void u_save_done(void); void c_save_done(void); static inline void save_done(void) { (pointer_compression_enabled ? c_save_done : u_save_done)(); }
void u_module_init(void); void c_module_init(void); static inline void module_init(void) { (pointer_compression_enabled ? c_module_init : u_module_init)(); }
void u_module_done(void); void c_module_done(void); static inline void module_done(void) { (pointer_compression_enabled ? c_module_done : u_module_done)(); }
void u_ipio_init(void); void c_ipio_init(void); static inline void ipio_init(void) { (pointer_compression_enabled ? c_ipio_init : u_ipio_init)(); }
void u_ipio_done(void); void c_ipio_done(void); static inline void ipio_done(void) { (pointer_compression_enabled ? c_ipio_done : u_ipio_done)(); }
void u_ipret_init(void); void c_ipret_init(void); static inline void ipret_init(void) { (pointer_compression_enabled ? c_ipret_init : u_ipret_init)(); }
void u_ipret_done(void); void c_ipret_done(void); static inline void ipret_done(void) { (pointer_compression_enabled ? c_ipret_done : u_ipret_done)(); }
void u_task_init(void); void c_task_init(void); static inline void task_init(void) { (pointer_compression_enabled ? c_task_init : u_task_init)(); }
void u_task_done(void); void c_task_done(void); static inline void task_done(void) { (pointer_compression_enabled ? c_task_done : u_task_done)(); }
void u_task_run(void); void c_task_run(void); static inline void task_run(void) { (pointer_compression_enabled ? c_task_run : u_task_run)(); }
void u_program_run(void); void c_program_run(void); static inline void program_run(void) { (pointer_compression_enabled ? c_program_run : u_program_run)(); }
void u_bist(void); void c_bist(void); static inline void bist(void) { (pointer_compression_enabled ? c_bist : u_bist)(); }
# 20 "ipret.c" 2



# 1 "./mem_al.h" 1
# 23 "./mem_al.h"
extern uchar_efficient_t amalloc_enabled;




void * mem_alloc_position(size_t size, ajla_error_t *mayfail , const char __attribute__((__unused__)) *position_arg);
void * mem_calloc_position(size_t size, ajla_error_t *mayfail , const char __attribute__((__unused__)) *position_arg);
void * mem_align_position(size_t size, size_t alignment, ajla_error_t *mayfail , const char __attribute__((__unused__)) *position_arg);
void * mem_calign_position(size_t size, size_t alignment, ajla_error_t *mayfail , const char __attribute__((__unused__)) *position_arg);
void * mem_realloc_position(void *ptr, size_t size, ajla_error_t *mayfail , const char __attribute__((__unused__)) *position_arg);
void mem_free_position(const void *ptr , const char __attribute__((__unused__)) *position_arg);
void mem_free_aligned_position(const void *ptr , const char __attribute__((__unused__)) *position_arg);
# 57 "./mem_al.h"
void mem_set_position(const void *ptr , const char __attribute__((__unused__)) *position_arg);
const char * mem_get_position(const void *ptr , const char __attribute__((__unused__)) *position_arg);
void mem_verify_position(const void __attribute__((__unused__)) *ptr , const char __attribute__((__unused__)) *position_arg);
void mem_verify_aligned_position(const void __attribute__((__unused__)) *ptr , const char __attribute__((__unused__)) *position_arg);
# 72 "./mem_al.h"
_Bool mem_trim_cache(void);





void mem_report_usage(int mode, const char *string);




_Bool mem_enable_debugging_option(const char *option, size_t l);
_Bool mem_al_enable_profile(const char *option, size_t l);
void mem_al_set_ptrcomp(const char *str);
void mem_al_set_system_malloc(const char __attribute__((__unused__)) *str);
void mem_init(void);
void mem_init_multithreaded(void);
void mem_done_multithreaded(void);
void mem_done(void);

static inline _Bool mem_check_overflow(size_t prefix, size_t n_elements, size_t el_size, ajla_error_t *err)
{
 if ((__builtin_expect((int)(n_elements > (size_t_limit - prefix) / el_size), 0))) {
  fatal_mayfail(error_ajla_aux_(1, 3, 0 , "./mem_al.h" ":" "95"), err, "allocation size overflow: %" "l" "u" " + %" "l" "u" " * %" "l" "u" "", (uintmax_t)prefix, (uintmax_t)n_elements, (uintmax_t)el_size);
  return 0;
 }
 return 1;
}
# 24 "ipret.c" 2
# 1 "./data.h" 1
# 22 "./data.h"
# 1 "./args.h" 1
# 22 "./args.h"
extern const char * const * args_left;
extern int n_args_left;
extern const char *program_name;
extern const char *arg0;

void args_init(int argc, const char * const argv[]);
void args_done(void);
# 23 "./data.h" 2
# 1 "./type.h" 1
# 22 "./type.h"
# 1 "./list.h" 1
# 22 "./list.h"
struct list {
 struct list *next, *prev;
};
# 55 "./list.h"
static inline void list_init(struct list *head)
{
 head->next = head->prev = head;
}

static inline void list_init_add(struct list *head, struct list *entry)
{
 head->next = head->prev = entry;
 entry->next = entry->prev = head;
}

static inline void list_add_(struct list *head, struct list *entry, const char __attribute__((__unused__)) *position)
{
# 80 "./list.h"
 entry->prev = head;
 entry->next = head->next;
 head->next->prev = entry;
 head->next = entry;
}



static inline void list_del_(struct list *entry, const char __attribute__((__unused__)) *position)
{
 ((void)0);
 entry->prev->next = entry->next;
 entry->next->prev = entry->prev;




}



static inline _Bool list_is_empty_(struct list *head, const char __attribute__((__unused__)) *position)
{
 ((void)0);
 return head->next == head;
}

static inline void list_take_(struct list *dst, struct list *src, const char __attribute__((__unused__)) *position)
{
 if (list_is_empty_(src, position)) {
  list_init(dst);
 } else {
  *dst = *src;
  dst->next->prev = dst;
  dst->prev->next = dst;
  list_init(src);
 }
}
# 23 "./type.h" 2

typedef unsigned char flat_size_t;
typedef uchar_efficient_t type_tag_t;
# 60 "./type.h"
struct type {
 type_tag_t tag;
 unsigned char depth;
 _Bool extra_compare;
 flat_size_t size;
 flat_size_t align;
};

static inline _Bool type_is_equal(const struct type *t1, const struct type *t2)
{
 return t1 == t2 || (
  t1->tag == t2->tag &&
  t1->size == t2->size &&
  t1->align == t2->align);
}



const struct type *type_get_fixed(unsigned bits, _Bool uns);
const struct type *type_get_int(unsigned idx);
const struct type *type_get_real(unsigned idx);
const struct type *type_get_flat_option(void);
const struct type *type_get_unknown(void);
const struct type *type_get_from_tag(type_tag_t tag);


struct record_definition {
 struct type type;
 frame_t n_slots;
 frame_t alignment;
 arg_t n_entries;
 struct list entry;
 const frame_t *idx_to_frame;
 const struct type *types[];
};

struct record_definition *type_alloc_record_definition(frame_t size, ajla_error_t *mayfail);

static inline _Bool record_definition_is_elided(const struct record_definition *def, arg_t idx)
{
 ((void)(zero_()));
 return def->idx_to_frame[idx] == ((frame_t)-1);
}

static inline frame_t record_definition_slot(const struct record_definition *def, arg_t idx)
{
 frame_t slot;
 ((void)(zero_()));
 slot = def->idx_to_frame[idx];
 ((void)(zero_()));
 return slot;
}


struct flat_record_definition_entry {
 flat_size_t flat_offset;
 const struct type *subtype;
};

struct flat_type_head {
 struct type type;
};

struct flat_record_definition {
 struct type type;
 const struct type *base;
 struct flat_record_definition_entry entries[];
};





struct flat_array_definition {
 struct type type;
 const struct type *base;
 flat_size_t n_elements;
};


struct type_entry;
struct type_entry *type_prepare_flat_record(const struct type *base, ajla_error_t *mayfail);
void type_set_flat_record_entry(struct type_entry *def, arg_t idx, const struct type *subtype);
const struct type *type_get_flat_record(struct type_entry *def, ajla_error_t *mayfail);
void type_free_flat_record(struct type_entry *def);

const struct type *type_get_flat_array(const struct type *base, pcode_t n_elements, ajla_error_t *mayfail);


int type_memcmp(const unsigned char *flat1, const unsigned char *flat2, const struct type *type, size_t n);


void type_init(void);
void type_done(void);
# 24 "./data.h" 2

# 1 "./util.h" 1
# 22 "./util.h"
# 1 "./code-op.h" 1
# 22 "./code-op.h"
typedef uint16_t code_t;
# 254 "./code-op.h"
enum {
 OPCODE_INT_LDC_LONG = ((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 9),
 OPCODE_IS_EXCEPTION,
 OPCODE_EXCEPTION_CLASS,
 OPCODE_EXCEPTION_TYPE,
 OPCODE_EXCEPTION_AUX,
 OPCODE_SYSTEM_PROPERTY,
 OPCODE_FLAT_MOVE,
 OPCODE_FLAT_COPY,
 OPCODE_REF_MOVE,
 OPCODE_REF_MOVE_CLEAR,
 OPCODE_REF_COPY,
 OPCODE_BOX_MOVE_CLEAR,
 OPCODE_BOX_COPY,
 OPCODE_TAKE_BORROWED,
 OPCODE_DEREFERENCE,
 OPCODE_DEREFERENCE_CLEAR,
 OPCODE_EVAL,
 OPCODE_CHECKPOINT,
 OPCODE_JMP,
 OPCODE_JMP_BACK_16,
 OPCODE_JMP_FALSE,
 OPCODE_LABEL,
 OPCODE_LOAD_FN,
 OPCODE_CURRY,
 OPCODE_CALL,
 OPCODE_CALL_STRICT,
 OPCODE_CALL_SPARK,
 OPCODE_CALL_LAZY,
 OPCODE_CALL_CACHE,
 OPCODE_CALL_SAVE,
 OPCODE_CALL_INDIRECT,
 OPCODE_CALL_INDIRECT_STRICT,
 OPCODE_CALL_INDIRECT_SPARK,
 OPCODE_CALL_INDIRECT_LAZY,
 OPCODE_CALL_INDIRECT_CACHE,
 OPCODE_CALL_INDIRECT_SAVE,
 OPCODE_RETURN,
 OPCODE_STRUCTURED,






 OPCODE_RECORD_CREATE,
 OPCODE_RECORD_LOAD,
 OPCODE_OPTION_CREATE_EMPTY_FLAT,
 OPCODE_OPTION_CREATE_EMPTY,
 OPCODE_OPTION_CREATE,
 OPCODE_OPTION_LOAD,
 OPCODE_OPTION_TEST_FLAT,
 OPCODE_OPTION_TEST,
 OPCODE_OPTION_ORD_FLAT,
 OPCODE_OPTION_ORD,
 OPCODE_ARRAY_CREATE,
 OPCODE_ARRAY_CREATE_EMPTY_FLAT,
 OPCODE_ARRAY_CREATE_EMPTY,
 OPCODE_ARRAY_FILL,
 OPCODE_ARRAY_STRING,
 OPCODE_ARRAY_UNICODE,
 OPCODE_ARRAY_LOAD,
 OPCODE_ARRAY_LEN,
 OPCODE_ARRAY_LEN_GREATER_THAN,
 OPCODE_ARRAY_SUB,
 OPCODE_ARRAY_SKIP,
 OPCODE_ARRAY_APPEND,
 OPCODE_ARRAY_APPEND_ONE_FLAT,
 OPCODE_ARRAY_APPEND_ONE,
 OPCODE_ARRAY_FLATTEN,
 OPCODE_IO,
 OPCODE_INTERNAL_FUNCTION,
 OPCODE_EXIT_THREAD,
 OPCODE_UNREACHABLE,
 OPCODE_N,
};

enum {
 OPCODE_MODE_MULT_0 = (OPCODE_N - 1),
 OPCODE_MODE_MULT_1 = (OPCODE_MODE_MULT_0 | (OPCODE_MODE_MULT_0 >> 1)),
 OPCODE_MODE_MULT_2 = (OPCODE_MODE_MULT_1 | (OPCODE_MODE_MULT_1 >> 2)),
 OPCODE_MODE_MULT_4 = (OPCODE_MODE_MULT_2 | (OPCODE_MODE_MULT_2 >> 4)),
 OPCODE_MODE_MULT_8 = (OPCODE_MODE_MULT_4 | (OPCODE_MODE_MULT_4 >> 8)),
 OPCODE_MODE_MULT = OPCODE_MODE_MULT_8 + 1,
};
# 23 "./util.h" 2

void memcpy_fast(void *dest, const void *src, size_t size);
const char *decode_opcode(code_t o, _Bool allow_invalid);
# 26 "./data.h" 2
# 1 "./refcount.h" 1
# 22 "./refcount.h"
# 1 "./addrlock.h" 1
# 22 "./addrlock.h"
# 1 "./thread.h" 1
# 23 "./thread.h"
# 1 "./asm.h" 1
# 24 "./asm.h"
typedef unsigned cpu_feature_mask_t;

extern cpu_feature_mask_t cpu_feature_flags;

enum {

# 1 "./asm.inc" 1
# 47 "./asm.inc"
# 1 "./asm-x86.inc" 1
# 22 "./asm-x86.inc"
# 1 "./asm-1.inc" 1
# 20 "./asm-1.inc"
 CPU_FEATURE_bswap,
# 23 "./asm-x86.inc" 2




# 1 "./asm-1.inc" 1
# 20 "./asm-1.inc"
 CPU_FEATURE_cmov,
# 28 "./asm-x86.inc" 2




# 1 "./asm-1.inc" 1
# 20 "./asm-1.inc"
 CPU_FEATURE_popcnt,
# 33 "./asm-x86.inc" 2




# 1 "./asm-1.inc" 1
# 20 "./asm-1.inc"
 CPU_FEATURE_lzcnt,
# 38 "./asm-x86.inc" 2




# 1 "./asm-1.inc" 1
# 20 "./asm-1.inc"
 CPU_FEATURE_sse,
# 43 "./asm-x86.inc" 2




# 1 "./asm-1.inc" 1
# 20 "./asm-1.inc"
 CPU_FEATURE_sse2,
# 48 "./asm-x86.inc" 2




# 1 "./asm-1.inc" 1
# 20 "./asm-1.inc"
 CPU_FEATURE_sse3,
# 53 "./asm-x86.inc" 2




# 1 "./asm-1.inc" 1
# 20 "./asm-1.inc"
 CPU_FEATURE_sse41,
# 58 "./asm-x86.inc" 2




# 1 "./asm-1.inc" 1
# 20 "./asm-1.inc"
 CPU_FEATURE_avx,
# 63 "./asm-x86.inc" 2




# 1 "./asm-1.inc" 1
# 20 "./asm-1.inc"
 CPU_FEATURE_f16c,
# 68 "./asm-x86.inc" 2




# 1 "./asm-1.inc" 1
# 20 "./asm-1.inc"
 CPU_FEATURE_erms,
# 73 "./asm-x86.inc" 2
# 48 "./asm.inc" 2
# 31 "./asm.h" 2

 CPU_FEATURE_max
};

enum {
cpu_feature_static_flags = 0

# 1 "./asm.inc" 1
# 47 "./asm.inc"
# 1 "./asm-x86.inc" 1
# 22 "./asm-x86.inc"
# 1 "./asm-1.inc" 1
# 27 "./asm-1.inc"
 | (1 << CPU_FEATURE_bswap)
# 23 "./asm-x86.inc" 2




# 1 "./asm-1.inc" 1
# 27 "./asm-1.inc"
 | (1 << CPU_FEATURE_cmov)
# 28 "./asm-x86.inc" 2




# 1 "./asm-1.inc" 1
# 29 "./asm-1.inc"
 | 0
# 33 "./asm-x86.inc" 2




# 1 "./asm-1.inc" 1
# 29 "./asm-1.inc"
 | 0
# 38 "./asm-x86.inc" 2




# 1 "./asm-1.inc" 1
# 27 "./asm-1.inc"
 | (1 << CPU_FEATURE_sse)
# 43 "./asm-x86.inc" 2




# 1 "./asm-1.inc" 1
# 27 "./asm-1.inc"
 | (1 << CPU_FEATURE_sse2)
# 48 "./asm-x86.inc" 2




# 1 "./asm-1.inc" 1
# 29 "./asm-1.inc"
 | 0
# 53 "./asm-x86.inc" 2




# 1 "./asm-1.inc" 1
# 29 "./asm-1.inc"
 | 0
# 58 "./asm-x86.inc" 2




# 1 "./asm-1.inc" 1
# 29 "./asm-1.inc"
 | 0
# 63 "./asm-x86.inc" 2




# 1 "./asm-1.inc" 1
# 29 "./asm-1.inc"
 | 0
# 68 "./asm-x86.inc" 2




# 1 "./asm-1.inc" 1
# 29 "./asm-1.inc"
 | 0
# 73 "./asm-x86.inc" 2
# 48 "./asm.inc" 2
# 39 "./asm.h" 2

};





void asm_setup_thread(void);
code_t code_alt(code_t code);


void asm_init(void);
void asm_done(void);
# 24 "./thread.h" 2
# 47 "./thread.h"
typedef void tls_t_;
# 59 "./thread.h"
void tls_destructor_call(void);
# 134 "./thread.h"
# 1 "/usr/include/pthread.h" 1 3 4
# 22 "/usr/include/pthread.h" 3 4
# 1 "/usr/include/sched.h" 1 3 4
# 29 "/usr/include/sched.h" 3 4
# 1 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 1 3 4
# 93 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 3 4
# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_size_t.h" 1 3 4
# 94 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3 4
# 108 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 3 4
# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_null.h" 1 3 4
# 109 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3 4
# 30 "/usr/include/sched.h" 2 3 4
# 43 "/usr/include/sched.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/sched.h" 1 3 4
# 80 "/usr/include/x86_64-linux-gnu/bits/sched.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h" 3 4
struct sched_param
{
  int sched_priority;
};
# 81 "/usr/include/x86_64-linux-gnu/bits/sched.h" 2 3 4





extern int clone (int (*__fn) (void *__arg), void *__child_stack,
    int __flags, void *__arg, ...) __attribute__ ((__nothrow__ ));


extern int unshare (int __flags) __attribute__ ((__nothrow__ ));


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


extern int getcpu (unsigned int *, unsigned int *) __attribute__ ((__nothrow__ ));


extern int setns (int __fd, int __nstype) __attribute__ ((__nothrow__ ));
# 44 "/usr/include/sched.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/cpu-set.h" 1 3 4
# 32 "/usr/include/x86_64-linux-gnu/bits/cpu-set.h" 3 4
typedef unsigned long int __cpu_mask;






typedef struct
{
  __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
} cpu_set_t;
# 117 "/usr/include/x86_64-linux-gnu/bits/cpu-set.h" 3 4
extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
     __attribute__ ((__nothrow__ ));
extern cpu_set_t *__sched_cpualloc (size_t __count) __attribute__ ((__nothrow__ )) ;
extern void __sched_cpufree (cpu_set_t *__set) __attribute__ ((__nothrow__ ));
# 45 "/usr/include/sched.h" 2 3 4
# 54 "/usr/include/sched.h" 3 4
extern int sched_setparam (__pid_t __pid, const struct sched_param *__param)
     __attribute__ ((__nothrow__ ));


extern int sched_getparam (__pid_t __pid, struct sched_param *__param) __attribute__ ((__nothrow__ ));


extern int sched_setscheduler (__pid_t __pid, int __policy,
          const struct sched_param *__param) __attribute__ ((__nothrow__ ));


extern int sched_getscheduler (__pid_t __pid) __attribute__ ((__nothrow__ ));


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


extern int sched_get_priority_max (int __algorithm) __attribute__ ((__nothrow__ ));


extern int sched_get_priority_min (int __algorithm) __attribute__ ((__nothrow__ ));



extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) __attribute__ ((__nothrow__ ));
# 130 "/usr/include/sched.h" 3 4
extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
         const cpu_set_t *__cpuset) __attribute__ ((__nothrow__ ));


extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
         cpu_set_t *__cpuset) __attribute__ ((__nothrow__ ));
# 23 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/time.h" 1 3 4
# 29 "/usr/include/time.h" 3 4
# 1 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 1 3 4
# 93 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 3 4
# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_size_t.h" 1 3 4
# 94 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3 4
# 108 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 3 4
# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_null.h" 1 3 4
# 109 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3 4
# 30 "/usr/include/time.h" 2 3 4



# 1 "/usr/include/x86_64-linux-gnu/bits/time.h" 1 3 4
# 73 "/usr/include/x86_64-linux-gnu/bits/time.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/timex.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/bits/timex.h" 3 4
struct timex
{
# 58 "/usr/include/x86_64-linux-gnu/bits/timex.h" 3 4
  unsigned int modes;
  __syscall_slong_t offset;
  __syscall_slong_t freq;
  __syscall_slong_t maxerror;
  __syscall_slong_t esterror;
  int status;
  __syscall_slong_t constant;
  __syscall_slong_t precision;
  __syscall_slong_t tolerance;
  struct timeval time;
  __syscall_slong_t tick;
  __syscall_slong_t ppsfreq;
  __syscall_slong_t jitter;
  int shift;
  __syscall_slong_t stabil;
  __syscall_slong_t jitcnt;
  __syscall_slong_t calcnt;
  __syscall_slong_t errcnt;
  __syscall_slong_t stbcnt;

  int tai;


  int :32; int :32; int :32; int :32;
  int :32; int :32; int :32; int :32;
  int :32; int :32; int :32;

};
# 74 "/usr/include/x86_64-linux-gnu/bits/time.h" 2 3 4




extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (2)));
# 34 "/usr/include/time.h" 2 3 4





# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_tm.h" 1 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;




};
# 40 "/usr/include/time.h" 2 3 4








# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h" 1 3 4







struct itimerspec
  {
    struct timespec it_interval;
    struct timespec it_value;
  };
# 49 "/usr/include/time.h" 2 3 4
struct sigevent;
# 72 "/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__ ));
# 100 "/usr/include/time.h" 3 4
extern size_t strftime (char *__restrict __s, size_t __maxsize,
   const char *__restrict __format,
   const struct tm *__restrict __tp)
   __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 3, 4)));




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__ ));
# 155 "/usr/include/time.h" 3 4
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__ ));
# 180 "/usr/include/time.h" 3 4
extern char *asctime (const struct tm *__tp) __attribute__ ((__nothrow__ ));



extern char *ctime (const time_t *__timer) __attribute__ ((__nothrow__ ));
# 198 "/usr/include/time.h" 3 4
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__ ));
# 218 "/usr/include/time.h" 3 4
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;
# 247 "/usr/include/time.h" 3 4
extern time_t timegm (struct tm *__tp) __attribute__ ((__nothrow__ ));
# 264 "/usr/include/time.h" 3 4
extern time_t timelocal (struct tm *__tp) __attribute__ ((__nothrow__ ));







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


extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (2)));
# 324 "/usr/include/time.h" 3 4
extern int clock_nanosleep (clockid_t __clock_id, int __flags,
       const struct timespec *__req,
       struct timespec *__rem);
# 339 "/usr/include/time.h" 3 4
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__ ));
# 377 "/usr/include/time.h" 3 4
extern int timer_getoverrun (timer_t __timerid) __attribute__ ((__nothrow__ ));






extern int timespec_get (struct timespec *__ts, int __base)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));
# 400 "/usr/include/time.h" 3 4
extern int timespec_getres (struct timespec *__ts, int __base)
     __attribute__ ((__nothrow__ ));
# 426 "/usr/include/time.h" 3 4
extern int getdate_err;
# 435 "/usr/include/time.h" 3 4
extern struct tm *getdate (const char *__string);
# 449 "/usr/include/time.h" 3 4
extern int getdate_r (const char *__restrict __string,
        struct tm *__restrict __resbufp);
# 24 "/usr/include/pthread.h" 2 3 4



# 1 "/usr/include/x86_64-linux-gnu/bits/setjmp.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/bits/setjmp.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/setjmp.h" 2 3 4




typedef long int __jmp_buf[8];
# 28 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 29 "/usr/include/pthread.h" 2 3 4


# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h" 3 4
struct __jmp_buf_tag
  {




    __jmp_buf __jmpbuf;
    int __mask_was_saved;
    __sigset_t __saved_mask;
  };
# 32 "/usr/include/pthread.h" 2 3 4

# 1 "/usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h" 3 4
extern long int __sysconf (int __name) __attribute__ ((__nothrow__ ));
# 34 "/usr/include/pthread.h" 2 3 4



enum
{
  PTHREAD_CREATE_JOINABLE,

  PTHREAD_CREATE_DETACHED

};



enum
{
  PTHREAD_MUTEX_TIMED_NP,
  PTHREAD_MUTEX_RECURSIVE_NP,
  PTHREAD_MUTEX_ERRORCHECK_NP,
  PTHREAD_MUTEX_ADAPTIVE_NP

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



  , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP

};




enum
{
  PTHREAD_MUTEX_STALLED,
  PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED,
  PTHREAD_MUTEX_ROBUST,
  PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST
};





enum
{
  PTHREAD_PRIO_NONE,
  PTHREAD_PRIO_INHERIT,
  PTHREAD_PRIO_PROTECT
};
# 104 "/usr/include/pthread.h" 3 4
enum
{
  PTHREAD_RWLOCK_PREFER_READER_NP,
  PTHREAD_RWLOCK_PREFER_WRITER_NP,
  PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
  PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP
};
# 124 "/usr/include/pthread.h" 3 4
enum
{
  PTHREAD_INHERIT_SCHED,

  PTHREAD_EXPLICIT_SCHED

};



enum
{
  PTHREAD_SCOPE_SYSTEM,

  PTHREAD_SCOPE_PROCESS

};



enum
{
  PTHREAD_PROCESS_PRIVATE,

  PTHREAD_PROCESS_SHARED

};
# 159 "/usr/include/pthread.h" 3 4
struct _pthread_cleanup_buffer
{
  void (*__routine) (void *);
  void *__arg;
  int __canceltype;
  struct _pthread_cleanup_buffer *__prev;
};


enum
{
  PTHREAD_CANCEL_ENABLE,

  PTHREAD_CANCEL_DISABLE

};
enum
{
  PTHREAD_CANCEL_DEFERRED,

  PTHREAD_CANCEL_ASYNCHRONOUS

};
# 202 "/usr/include/pthread.h" 3 4
extern int pthread_create (pthread_t *__restrict __newthread,
      const pthread_attr_t *__restrict __attr,
      void *(*__start_routine) (void *),
      void *__restrict __arg) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 3)));





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







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




extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) __attribute__ ((__nothrow__ ));
# 233 "/usr/include/pthread.h" 3 4
extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
     const struct timespec *__abstime);
# 243 "/usr/include/pthread.h" 3 4
extern int pthread_clockjoin_np (pthread_t __th, void **__thread_return,
                                 clockid_t __clockid,
     const struct timespec *__abstime);
# 269 "/usr/include/pthread.h" 3 4
extern int pthread_detach (pthread_t __th) __attribute__ ((__nothrow__ ));



extern pthread_t pthread_self (void) __attribute__ ((__nothrow__ )) __attribute__ ((__const__));


extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
  __attribute__ ((__nothrow__ )) __attribute__ ((__const__));







extern int pthread_attr_init (pthread_attr_t *__attr) __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_destroy (pthread_attr_t *__attr)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
     int *__detachstate)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
     int __detachstate)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
          size_t *__guardsize)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
          size_t __guardsize)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
           struct sched_param *__restrict __param)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
           const struct sched_param *__restrict
           __param) __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
     __attr, int *__restrict __policy)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
      __attr, int *__restrict __inherit)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
      int __inherit)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
      int *__restrict __scope)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
          __attr, void **__restrict __stackaddr)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));





extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
          void *__stackaddr)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));


extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
          __attr, size_t *__restrict __stacksize)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 2)));




extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
          size_t __stacksize)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
      void **__restrict __stackaddr,
      size_t *__restrict __stacksize)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 2, 3)));




extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
      size_t __stacksize) __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));





extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
     size_t __cpusetsize,
     const cpu_set_t *__cpuset)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 3)));



extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
     size_t __cpusetsize,
     cpu_set_t *__cpuset)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 3)));


extern int pthread_getattr_default_np (pthread_attr_t *__attr)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_setsigmask_np (pthread_attr_t *__attr,
           const __sigset_t *sigmask);




extern int pthread_attr_getsigmask_np (const pthread_attr_t *__attr,
           __sigset_t *sigmask);







extern int pthread_setattr_default_np (const pthread_attr_t *__attr)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));




extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (2)));







extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
      const struct sched_param *__param)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (3)));


extern int pthread_getschedparam (pthread_t __target_thread,
      int *__restrict __policy,
      struct sched_param *__restrict __param)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (2, 3)));


extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
     __attribute__ ((__nothrow__ ));




extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
          size_t __buflen)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (2)));


extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (2)));





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


extern int pthread_setconcurrency (int __level) __attribute__ ((__nothrow__ ));



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

extern int pthread_yield (void) __asm__ ("" "sched_yield") __attribute__ ((__nothrow__ ))
  __attribute__ ((__deprecated__ ("pthread_yield is deprecated, use sched_yield instead")));
# 489 "/usr/include/pthread.h" 3 4
extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
       const cpu_set_t *__cpuset)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (3)));


extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
       cpu_set_t *__cpuset)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (3)));
# 509 "/usr/include/pthread.h" 3 4
extern int pthread_once (pthread_once_t *__once_control,
    void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
# 521 "/usr/include/pthread.h" 3 4
extern int pthread_setcancelstate (int __state, int *__oldstate);



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


extern int pthread_cancel (pthread_t __th);




extern void pthread_testcancel (void);




struct __cancel_jmp_buf_tag
{
  __jmp_buf __cancel_jmp_buf;
  int __mask_was_saved;
};

typedef struct
{
  struct __cancel_jmp_buf_tag __cancel_jmp_buf[1];
  void *__pad[4];
} __pthread_unwind_buf_t __attribute__ ((__aligned__));
# 557 "/usr/include/pthread.h" 3 4
struct __pthread_cleanup_frame
{
  void (*__cancel_routine) (void *);
  void *__cancel_arg;
  int __do_it;
  int __cancel_type;
};
# 697 "/usr/include/pthread.h" 3 4
extern void __pthread_register_cancel (__pthread_unwind_buf_t *__buf)
                            ;
# 709 "/usr/include/pthread.h" 3 4
extern void __pthread_unregister_cancel (__pthread_unwind_buf_t *__buf)
                         ;
# 732 "/usr/include/pthread.h" 3 4
extern void __pthread_register_cancel_defer (__pthread_unwind_buf_t *__buf)
                            ;
# 745 "/usr/include/pthread.h" 3 4
extern void __pthread_unregister_cancel_restore (__pthread_unwind_buf_t *__buf)
                         ;



extern void __pthread_unwind_next (__pthread_unwind_buf_t *__buf)
                             __attribute__ ((__noreturn__))

     __attribute__ ((__weak__))

     ;
# 773 "/usr/include/pthread.h" 3 4
extern int __sigsetjmp (struct __jmp_buf_tag __env[1],
   int __savemask) __attribute__ ((__nothrow__));






extern int pthread_mutex_init (pthread_mutex_t *__mutex,
          const pthread_mutexattr_t *__mutexattr)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));




extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
        const struct timespec *__restrict
        __abstime) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
# 817 "/usr/include/pthread.h" 3 4
extern int pthread_mutex_clocklock (pthread_mutex_t *__restrict __mutex,
        clockid_t __clockid,
        const struct timespec *__restrict
        __abstime) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 3)));
# 835 "/usr/include/pthread.h" 3 4
extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));



extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
      __restrict __mutex,
      int *__restrict __prioceiling)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
      int __prioceiling,
      int *__restrict __old_ceiling)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 3)));




extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutex_consistent_np (pthread_mutex_t *) __asm__ ("" "pthread_mutex_consistent") __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)))

  __attribute__ ((__deprecated__ ("pthread_mutex_consistent_np is deprecated, use pthread_mutex_consistent")));
# 874 "/usr/include/pthread.h" 3 4
extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
      __restrict __attr,
      int *__restrict __pshared)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
      int __pshared)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));



extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
          __attr, int *__restrict __kind)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 2)));




extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));



extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
       __restrict __attr,
       int *__restrict __protocol)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
       int __protocol)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
          __restrict __attr,
          int *__restrict __prioceiling)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
          int __prioceiling)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));



extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
     int *__robustness)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_mutexattr_getrobust_np (pthread_mutexattr_t *, int *) __asm__ ("" "pthread_mutexattr_getrobust") __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)))


  __attribute__ ((__deprecated__ ("pthread_mutexattr_getrobust_np is deprecated, use pthread_mutexattr_getrobust")));







extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
     int __robustness)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *, int) __asm__ ("" "pthread_mutexattr_setrobust") __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)))


  __attribute__ ((__deprecated__ ("pthread_mutexattr_setrobust_np is deprecated, use pthread_mutexattr_setrobust")));
# 967 "/usr/include/pthread.h" 3 4
extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
    const pthread_rwlockattr_t *__restrict
    __attr) __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
  __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));




extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
           const struct timespec *__restrict
           __abstime) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
# 1004 "/usr/include/pthread.h" 3 4
extern int pthread_rwlock_clockrdlock (pthread_rwlock_t *__restrict __rwlock,
           clockid_t __clockid,
           const struct timespec *__restrict
           __abstime) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 3)));
# 1023 "/usr/include/pthread.h" 3 4
extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));




extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
           const struct timespec *__restrict
           __abstime) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
# 1051 "/usr/include/pthread.h" 3 4
extern int pthread_rwlock_clockwrlock (pthread_rwlock_t *__restrict __rwlock,
           clockid_t __clockid,
           const struct timespec *__restrict
           __abstime) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 3)));
# 1071 "/usr/include/pthread.h" 3 4
extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));





extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
       __restrict __attr,
       int *__restrict __pshared)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
       int __pshared)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
       __restrict __attr,
       int *__restrict __pref)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
       int __pref) __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));







extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
         const pthread_condattr_t *__restrict __cond_attr)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_cond_destroy (pthread_cond_t *__cond)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_cond_signal (pthread_cond_t *__cond)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern int pthread_cond_broadcast (pthread_cond_t *__cond)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));






extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
         pthread_mutex_t *__restrict __mutex)
     __attribute__ ((__nonnull__ (1, 2)));
# 1145 "/usr/include/pthread.h" 3 4
extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
       pthread_mutex_t *__restrict __mutex,
       const struct timespec *__restrict __abstime)
     __attribute__ ((__nonnull__ (1, 2, 3)));
# 1171 "/usr/include/pthread.h" 3 4
extern int pthread_cond_clockwait (pthread_cond_t *__restrict __cond,
       pthread_mutex_t *__restrict __mutex,
       __clockid_t __clock_id,
       const struct timespec *__restrict __abstime)
     __attribute__ ((__nonnull__ (1, 2, 4)));
# 1194 "/usr/include/pthread.h" 3 4
extern int pthread_condattr_init (pthread_condattr_t *__attr)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_condattr_getpshared (const pthread_condattr_t *
     __restrict __attr,
     int *__restrict __pshared)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
     int __pshared) __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));



extern int pthread_condattr_getclock (const pthread_condattr_t *
          __restrict __attr,
          __clockid_t *__restrict __clock_id)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
          __clockid_t __clock_id)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));
# 1230 "/usr/include/pthread.h" 3 4
extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_lock (pthread_spinlock_t *__lock)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));






extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
     const pthread_barrierattr_t *__restrict
     __attr, unsigned int __count)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));



extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
        __restrict __attr,
        int *__restrict __pshared)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
        int __pshared)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));
# 1297 "/usr/include/pthread.h" 3 4
extern int pthread_key_create (pthread_key_t *__key,
          void (*__destr_function) (void *))
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (1)));


extern int pthread_key_delete (pthread_key_t __key) __attribute__ ((__nothrow__ ));


extern void *pthread_getspecific (pthread_key_t __key) __attribute__ ((__nothrow__ ));


extern int pthread_setspecific (pthread_key_t __key,
    const void *__pointer)
  __attribute__ ((__nothrow__ )) ;




extern int pthread_getcpuclockid (pthread_t __thread_id,
      __clockid_t *__clock_id)
     __attribute__ ((__nothrow__ )) __attribute__ ((__nonnull__ (2)));
# 1332 "/usr/include/pthread.h" 3 4
extern int pthread_atfork (void (*__prepare) (void),
      void (*__parent) (void),
      void (*__child) (void)) __attribute__ ((__nothrow__ ));




extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__nothrow__ )) pthread_equal (pthread_t __thread1, pthread_t __thread2)
{
  return __thread1 == __thread2;
}
# 135 "./thread.h" 2

typedef pthread_mutex_t mutex_t;



typedef pthread_rwlock_t rwmutex_t;

typedef struct {
 pthread_mutex_t mutex;
 pthread_cond_t cond;
} cond_t;
typedef pthread_t thread_t;
typedef void *thread_function_t(void *arg);
# 200 "./thread.h"
void mutex_init_position(mutex_t * , const char __attribute__((__unused__)) *position_arg);
void mutex_done_position(mutex_t * , const char __attribute__((__unused__)) *position_arg);
void mutex_lock_position(mutex_t * , const char __attribute__((__unused__)) *position_arg);
_Bool mutex_trylock_position(mutex_t * , const char __attribute__((__unused__)) *position_arg);
void mutex_unlock_position(mutex_t * , const char __attribute__((__unused__)) *position_arg);
# 220 "./thread.h"
void rwmutex_init_position(rwmutex_t * , const char __attribute__((__unused__)) *position_arg);
void rwmutex_done_position(rwmutex_t * , const char __attribute__((__unused__)) *position_arg);
void rwmutex_lock_read_position(rwmutex_t * , const char __attribute__((__unused__)) *position_arg);
void rwmutex_unlock_read_position(rwmutex_t * , const char __attribute__((__unused__)) *position_arg);
void rwmutex_lock_write_position(rwmutex_t * , const char __attribute__((__unused__)) *position_arg);
void rwmutex_unlock_write_position(rwmutex_t * , const char __attribute__((__unused__)) *position_arg);
# 243 "./thread.h"
void cond_init_position(cond_t * , const char __attribute__((__unused__)) *position_arg);
void cond_done_position(cond_t * , const char __attribute__((__unused__)) *position_arg);
void cond_lock_position(cond_t * , const char __attribute__((__unused__)) *position_arg);
void cond_unlock_position(cond_t * , const char __attribute__((__unused__)) *position_arg);
void cond_unlock_signal_position(cond_t * , const char __attribute__((__unused__)) *position_arg);
void cond_unlock_broadcast_position(cond_t * , const char __attribute__((__unused__)) *position_arg);
void cond_wait_position(cond_t * , const char __attribute__((__unused__)) *position_arg);
_Bool cond_wait_us_position(cond_t *, uint32_t , const char __attribute__((__unused__)) *position_arg);
# 275 "./thread.h"
extern uchar_efficient_t thread_needs_barriers;
unsigned thread_concurrency(void);




typedef enum {
 PRIORITY_COMPUTE,
 PRIORITY_IO,
 PRIORITY_TIMER,
} thread_priority_t;
_Bool thread_spawn_position(thread_t *, thread_function_t *, void *, thread_priority_t priority, ajla_error_t *err , const char __attribute__((__unused__)) *position_arg);
void thread_join_position(thread_t * , const char __attribute__((__unused__)) *position_arg);





void tls_init__position(tls_t_ * , const char __attribute__((__unused__)) *position_arg);
void tls_done__position(tls_t_ * , const char __attribute__((__unused__)) *position_arg);
# 345 "./thread.h"
struct tls_destructor_s;
typedef void tls_destructor_fn(struct tls_destructor_s *);
typedef struct tls_destructor_s {
 struct tls_destructor_s *previous;
 tls_destructor_fn *fn;
} tls_destructor_t;
void tls_destructor_position(tls_destructor_t *, tls_destructor_fn * , const char __attribute__((__unused__)) *position_arg);
# 432 "./thread.h"
_Bool thread_enable_debugging_option(const char *option, size_t l);

void thread_init(void);
void thread_done(void);
# 23 "./addrlock.h" 2
# 70 "./addrlock.h"
typedef enum {
 DEPTH_THUNK,







 DEPTH_ARENA,





 DEPTH_AUX,
 N_POINTER_DEPTHS
} addrlock_depth;
# 120 "./addrlock.h"
void address_lock(const void *, addrlock_depth);
void address_unlock(const void *, addrlock_depth);
void address_lock_two(const void *, const void *, addrlock_depth);
_Bool address_trylock_second(const void *, const void *, addrlock_depth);
void address_unlock_second(const void *, const void *, addrlock_depth);
mutex_t * address_get_mutex(const void *, addrlock_depth);

void address_read_lock(const void *p);
void address_read_unlock(const void *p);
void address_write_lock(const void *p);
void address_write_unlock(const void *p);




static inline void address_lock_verify(void) { }


void address_lock_init(void);
void address_lock_done(void);
# 23 "./refcount.h" 2


# 1 "./ptrcomp.h" 1
# 26 "./refcount.h" 2
# 58 "./refcount.h"
typedef uintptr_t refcount_int_t;
# 76 "./refcount.h"
typedef struct {

 refcount_int_t refcount;
# 88 "./refcount.h"
} refcount_t;
# 120 "./refcount.h"
static inline __attribute__((__always_inline__)) void refcount_set_position(refcount_t __attribute__((__unused__)) *r, const char __attribute__((__unused__)) *position)
{







}

static inline __attribute__((__always_inline__)) void refcount_init_raw_(refcount_t *r, refcount_int_t val, const char *position)
{

 r->refcount = val;



 refcount_set_position(r, position);
}

static inline __attribute__((__always_inline__)) void refcount_init_(refcount_t *r, const char *position)
{
 refcount_init_raw_(r, 0, position);
}


static inline __attribute__((__always_inline__)) void refcount_init_tag_(refcount_t *r, unsigned char tag, const char *position)
{





 refcount_init_raw_(r, tag, position);
}


static inline __attribute__((__always_inline__)) void refcount_init_val_(refcount_t *r, refcount_int_t val, const char *position)
{
 refcount_init_raw_(r, (val - 1) * 256, position);
}
# 181 "./refcount.h"
static inline __attribute__((__always_inline__)) _Bool refcount_is_read_only(const refcount_t *r)
{
 refcount_int_t v = (*((volatile const refcount_int_t *)(void *)(&(r)->refcount)));



 return v >= (refcount_int_t)-256;

}

static inline __attribute__((__always_inline__)) void refcount_set_read_only(refcount_t *r)
{



 refcount_int_t val = (refcount_int_t)-256;


 val |= (*((volatile const refcount_int_t *)(void *)(&(r)->refcount))) & (256 - 1);

 refcount_init_raw_(r, val, "./refcount.h" ":" "201");
}

static inline __attribute__((__always_inline__)) _Bool refcount_is_invalid(const refcount_t __attribute__((__unused__)) *r)
{
 return !refcount_is_read_only(r) && (*((volatile const refcount_int_t *)(void *)(&(r)->refcount))) >= (((uintptr_t)1 << (8 * 8 - 1)) / (8 / 2));
}

static inline __attribute__((__always_inline__)) void refcount_validate(const refcount_t __attribute__((__unused__)) *r, const char __attribute__((__unused__)) *msg, const char __attribute__((__unused__)) *position)
{







}

static inline __attribute__((__always_inline__)) _Bool refcount_is_one_(const refcount_t *r, const char *position)
{
 refcount_validate(r, "refcount_is_one", position);
 return (*((volatile const refcount_int_t *)(void *)(&(r)->refcount))) < 256;
}


static inline __attribute__((__always_inline__)) unsigned char refcount_tag_get(const refcount_t *r)
{

 return ((volatile unsigned char *)&r->refcount)[0] & (256 - 1);





}


static inline __attribute__((__always_inline__)) void refcount_add_raw_(refcount_t *r, refcount_int_t add, const char *position)
{
 refcount_int_t __attribute__((__unused__)) value;
 if (position)
  refcount_validate(r, "refcount_add_raw", position);

 if (__builtin_constant_p(add) && add == 1)
  __asm__ volatile ("lock; inc""q"" %0"::"m"(r->refcount):"cc","memory");
 else if (__builtin_constant_p(add) && add == (refcount_int_t)-1)
  __asm__ volatile ("lock; dec""q"" %0"::"m"(r->refcount):"cc","memory");
 else
  __asm__ volatile ("lock; add""q"" %1, %0"::"m"(r->refcount),"ir"(add):"cc","memory");



 value = 256;
# 283 "./refcount.h"
}


static inline __attribute__((__always_inline__)) void refcount_tag_set_(refcount_t *r, unsigned char old_tag, unsigned char new_tag, const char __attribute__((__unused__)) *position)
{




 refcount_add_raw_(r, (refcount_int_t)new_tag - (refcount_int_t)old_tag, ((void*)0));
}


static inline __attribute__((__always_inline__)) void refcount_poison_(refcount_t __attribute__((__unused__)) *r, const char __attribute__((__unused__)) *position)
{
# 306 "./refcount.h"
}

static inline __attribute__((__always_inline__)) void refcount_poison_tag_(refcount_t __attribute__((__unused__)) *r, const char __attribute__((__unused__)) *position)
{



}
# 327 "./refcount.h"
static inline __attribute__((__always_inline__)) _Bool refcount_dec_(refcount_t *r, const char *position)
{
 _Bool result;
 refcount_validate(r, "refcount_dec", position);
 refcount_set_position(r, position);

 do { if ((__builtin_expect((int)((*((volatile const refcount_int_t *)(void *)(&(r)->refcount))) < 256), 1))) { refcount_poison_(r, position); return 1; } } while (0);
 __asm__ goto ("lock; sub""q"" %1, %0; jc %l[x86_ret_true]"::"m"(r->refcount),"i"(256):"cc","memory":x86_ret_true);
 return 0;
x86_ret_true:
 refcount_poison_(r, position);
 return 1;
# 366 "./refcount.h"
 if (result)
  refcount_poison_(r, position);
 return result;
}



static inline __attribute__((__always_inline__)) _Bool refcount_xchgcmp(refcount_t *r, refcount_int_t val, refcount_int_t cmp)
{
 refcount_int_t result;
 val = (val - 1) * 256;

 __asm__ ("xchg""q"" %1, %0":"=r"(result):"m"(r->refcount),"0"(val):"memory");
# 395 "./refcount.h"
 return result == (cmp - 1) * 256;
}

static inline __attribute__((__always_inline__)) void refcount_set(refcount_t *r, refcount_int_t val)
{
 val = (val - 1) * 256;

 __asm__ ("mov""q"" %1, %0":"=m"(r->refcount):"ri"(val));
# 421 "./refcount.h"
}

static inline __attribute__((__always_inline__)) _Bool refcount_is_one_nonatomic_(const refcount_t *r, const char *position)
{
 refcount_validate(r, "refcount_is_one_nonatomic", position);
 return r->refcount < 256;
}

static inline __attribute__((__always_inline__)) void refcount_inc_nonatomic_(refcount_t *r, const char *position)
{
 refcount_validate(r, "refcount_inc_nonatomic", position);
 r->refcount += 256;




}

static inline __attribute__((__always_inline__)) _Bool refcount_dec_nonatomic_(refcount_t *r, const char *position)
{
 _Bool result;
 refcount_validate(r, "refcount_dec_nonatomic", position);
 refcount_init_raw_(r, r->refcount - 256, position);
 result = (refcount_int_t)r->refcount >= (refcount_int_t)-256;
 if (result)
  refcount_poison_(r, position);
 return result;
}

static inline __attribute__((__always_inline__)) refcount_int_t refcount_get_nonatomic_(refcount_t *r, const char *position)
{
 refcount_validate(r, "refcount_get_nonatomic", position);
 return (r->refcount / 256) + 1;
}
# 27 "./data.h" 2

# 1 "./mpint.h" 1
# 22 "./mpint.h"
# 1 "./str.h" 1
# 24 "./str.h"
void * array_realloc_mayfail(void *p, size_t element_size, size_t old_length, size_t new_length, void **err_ptr, ajla_error_t *mayfail);
void * array_finish_realloc(void *p, size_t length);
# 72 "./str.h"
void str_add_bytes(char **, size_t *, const char *, size_t);
void str_add_string(char **, size_t *, const char *);
void str_add_char(char **, size_t *, char);
void str_add_unsigned(char **, size_t *, uintbig_t, int);
void str_add_signed(char **, size_t *, intbig_t, int);
void str_add_hex(char **s, size_t *l, const char *hex);

char *str_dup(const char *str, size_t max_len, ajla_error_t *err);

static inline char *str_from_unsigned(uintbig_t i, int base)
{
 size_t str_l;
 char *str;
 do { (void)( *((&str_l)) = 0, *((&str)) = ((char *)(void *)(mem_alloc_position(0, ((void*)0) , "./str.h" ":" "85"))), (!((__builtin_constant_p(((void*)0)) && !return_ptr(((void*)0)))) && !*((&str)) ? 0 : 1)); } while (0);
 str_add_unsigned(&str, &str_l, i, base);
 do { str_add_char((&str), (&str_l), 0); (*((&str)) = (char *)array_finish_realloc(*((&str)), *((&str_l)) * sizeof(char))); } while (0);
 return str;
}

static inline char *str_from_signed(uintbig_t i, int base)
{
 size_t str_l;
 char *str;
 do { (void)( *((&str_l)) = 0, *((&str)) = ((char *)(void *)(mem_alloc_position(0, ((void*)0) , "./str.h" ":" "95"))), (!((__builtin_constant_p(((void*)0)) && !return_ptr(((void*)0)))) && !*((&str)) ? 0 : 1)); } while (0);
 str_add_signed(&str, &str_l, i, base);
 do { str_add_char((&str), (&str_l), 0); (*((&str)) = (char *)array_finish_realloc(*((&str)), *((&str_l)) * sizeof(char))); } while (0);
 return str;
}
# 23 "./mpint.h" 2






# 1 "/usr/include/x86_64-linux-gnu/gmp.h" 1 3 4
# 56 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
# 1 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 1 3 4
# 88 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 3 4
# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_ptrdiff_t.h" 1 3 4
# 89 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3 4




# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_size_t.h" 1 3 4
# 94 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3 4
# 103 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 3 4
# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_wchar_t.h" 1 3 4
# 104 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3 4
# 128 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 3 4
# 1 "/usr/lib/llvm-20/lib/clang/20/include/__stddef_offsetof.h" 1 3 4
# 129 "/usr/lib/llvm-20/lib/clang/20/include/stddef.h" 2 3 4
# 57 "/usr/include/x86_64-linux-gnu/gmp.h" 2 3 4
# 1 "/usr/lib/llvm-20/lib/clang/20/include/limits.h" 1 3 4
# 25 "/usr/lib/llvm-20/lib/clang/20/include/limits.h" 3 4
# 1 "/usr/include/limits.h" 1 3 4
# 26 "/usr/include/limits.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 27 "/usr/include/limits.h" 2 3 4
# 195 "/usr/include/limits.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 28 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 2 3 4
# 161 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 1 3 4
# 38 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 3 4
# 1 "/usr/include/linux/limits.h" 1 3 4
# 39 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 2 3 4
# 162 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 2 3 4
# 196 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/x86_64-linux-gnu/bits/posix2_lim.h" 1 3 4
# 200 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 1 3 4
# 64 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/uio_lim.h" 1 3 4
# 65 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 2 3 4
# 204 "/usr/include/limits.h" 2 3 4
# 26 "/usr/lib/llvm-20/lib/clang/20/include/limits.h" 2 3 4
# 58 "/usr/include/x86_64-linux-gnu/gmp.h" 2 3 4
# 142 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
typedef unsigned long int mp_limb_t;
typedef long int mp_limb_signed_t;


typedef unsigned long int mp_bitcnt_t;




typedef struct
{
  int _mp_alloc;

  int _mp_size;


  mp_limb_t *_mp_d;
} __mpz_struct;




typedef __mpz_struct MP_INT;
typedef __mpz_struct mpz_t[1];

typedef mp_limb_t * mp_ptr;
typedef const mp_limb_t * mp_srcptr;







typedef long int mp_size_t;
typedef long int mp_exp_t;


typedef struct
{
  __mpz_struct _mp_num;
  __mpz_struct _mp_den;
} __mpq_struct;

typedef __mpq_struct MP_RAT;
typedef __mpq_struct mpq_t[1];

typedef struct
{
  int _mp_prec;



  int _mp_size;


  mp_exp_t _mp_exp;
  mp_limb_t *_mp_d;
} __mpf_struct;


typedef __mpf_struct mpf_t[1];


typedef enum
{
  GMP_RAND_ALG_DEFAULT = 0,
  GMP_RAND_ALG_LC = GMP_RAND_ALG_DEFAULT
} gmp_randalg_t;


typedef struct
{
  mpz_t _mp_seed;
  gmp_randalg_t _mp_alg;
  union {
    void *_mp_lc;
  } _mp_algdata;
} __gmp_randstate_struct;
typedef __gmp_randstate_struct gmp_randstate_t[1];



typedef const __mpz_struct *mpz_srcptr;
typedef __mpz_struct *mpz_ptr;
typedef const __mpf_struct *mpf_srcptr;
typedef __mpf_struct *mpf_ptr;
typedef const __mpq_struct *mpq_srcptr;
typedef __mpq_struct *mpq_ptr;
typedef __gmp_randstate_struct *gmp_randstate_ptr;
typedef const __gmp_randstate_struct *gmp_randstate_srcptr;
# 481 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
               void __gmp_set_memory_functions (void *(*) (size_t),
          void *(*) (void *, size_t, size_t),
          void (*) (void *, size_t)) ;


               void __gmp_get_memory_functions (void *(**) (size_t),
          void *(**) (void *, size_t, size_t),
          void (**) (void *, size_t)) ;


               extern const int __gmp_bits_per_limb;


               extern int __gmp_errno;


               extern const char * const __gmp_version;






               void __gmp_randinit (gmp_randstate_ptr, gmp_randalg_t, ...);


               void __gmp_randinit_default (gmp_randstate_ptr);


               void __gmp_randinit_lc_2exp (gmp_randstate_ptr, mpz_srcptr, unsigned long int, mp_bitcnt_t);


               int __gmp_randinit_lc_2exp_size (gmp_randstate_ptr, mp_bitcnt_t);


               void __gmp_randinit_mt (gmp_randstate_ptr);


               void __gmp_randinit_set (gmp_randstate_ptr, gmp_randstate_srcptr);


               void __gmp_randseed (gmp_randstate_ptr, mpz_srcptr);


               void __gmp_randseed_ui (gmp_randstate_ptr, unsigned long int);


               void __gmp_randclear (gmp_randstate_ptr);


               unsigned long __gmp_urandomb_ui (gmp_randstate_ptr, unsigned long);


               unsigned long __gmp_urandomm_ui (gmp_randstate_ptr, unsigned long);





               int __gmp_asprintf (char **, const char *, ...);
# 558 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
               int __gmp_printf (const char *, ...);


               int __gmp_snprintf (char *, size_t, const char *, ...);


               int __gmp_sprintf (char *, const char *, ...);



               int __gmp_vasprintf (char **, const char *, va_list);
# 578 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
               int __gmp_vprintf (const char *, va_list);




               int __gmp_vsnprintf (char *, size_t, const char *, va_list);




               int __gmp_vsprintf (char *, const char *, va_list);
# 600 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
               int __gmp_scanf (const char *, ...);


               int __gmp_sscanf (const char *, const char *, ...);
# 612 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
               int __gmp_vscanf (const char *, va_list);




               int __gmp_vsscanf (const char *, const char *, va_list);







               void *__gmpz_realloc (mpz_ptr, mp_size_t);



               void __gmpz_abs (mpz_ptr, mpz_srcptr);



               void __gmpz_add (mpz_ptr, mpz_srcptr, mpz_srcptr);


               void __gmpz_add_ui (mpz_ptr, mpz_srcptr, unsigned long int);


               void __gmpz_addmul (mpz_ptr, mpz_srcptr, mpz_srcptr);


               void __gmpz_addmul_ui (mpz_ptr, mpz_srcptr, unsigned long int);


               void __gmpz_and (mpz_ptr, mpz_srcptr, mpz_srcptr);


               void __gmpz_array_init (mpz_ptr, mp_size_t, mp_size_t);


               void __gmpz_bin_ui (mpz_ptr, mpz_srcptr, unsigned long int);


               void __gmpz_bin_uiui (mpz_ptr, unsigned long int, unsigned long int);


               void __gmpz_cdiv_q (mpz_ptr, mpz_srcptr, mpz_srcptr);


               void __gmpz_cdiv_q_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);


               unsigned long int __gmpz_cdiv_q_ui (mpz_ptr, mpz_srcptr, unsigned long int);


               void __gmpz_cdiv_qr (mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr);


               unsigned long int __gmpz_cdiv_qr_ui (mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int);


               void __gmpz_cdiv_r (mpz_ptr, mpz_srcptr, mpz_srcptr);


               void __gmpz_cdiv_r_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);


               unsigned long int __gmpz_cdiv_r_ui (mpz_ptr, mpz_srcptr, unsigned long int);


               unsigned long int __gmpz_cdiv_ui (mpz_srcptr, unsigned long int) __attribute__ ((__pure__));


               void __gmpz_clear (mpz_ptr);


               void __gmpz_clears (mpz_ptr, ...);


               void __gmpz_clrbit (mpz_ptr, mp_bitcnt_t);


               int __gmpz_cmp (mpz_srcptr, mpz_srcptr) __attribute__ ((__pure__));


               int __gmpz_cmp_d (mpz_srcptr, double) __attribute__ ((__pure__));


               int __gmpz_cmp_si (mpz_srcptr, signed long int) __attribute__ ((__pure__));


               int __gmpz_cmp_ui (mpz_srcptr, unsigned long int) __attribute__ ((__pure__));


               int __gmpz_cmpabs (mpz_srcptr, mpz_srcptr) __attribute__ ((__pure__));


               int __gmpz_cmpabs_d (mpz_srcptr, double) __attribute__ ((__pure__));


               int __gmpz_cmpabs_ui (mpz_srcptr, unsigned long int) __attribute__ ((__pure__));


               void __gmpz_com (mpz_ptr, mpz_srcptr);


               void __gmpz_combit (mpz_ptr, mp_bitcnt_t);


               int __gmpz_congruent_p (mpz_srcptr, mpz_srcptr, mpz_srcptr) __attribute__ ((__pure__));


               int __gmpz_congruent_2exp_p (mpz_srcptr, mpz_srcptr, mp_bitcnt_t) __attribute__ ((__pure__));


               int __gmpz_congruent_ui_p (mpz_srcptr, unsigned long, unsigned long) __attribute__ ((__pure__));


               void __gmpz_divexact (mpz_ptr, mpz_srcptr, mpz_srcptr);


               void __gmpz_divexact_ui (mpz_ptr, mpz_srcptr, unsigned long);


               int __gmpz_divisible_p (mpz_srcptr, mpz_srcptr) __attribute__ ((__pure__));


               int __gmpz_divisible_ui_p (mpz_srcptr, unsigned long) __attribute__ ((__pure__));


               int __gmpz_divisible_2exp_p (mpz_srcptr, mp_bitcnt_t) __attribute__ ((__pure__));


               void __gmpz_dump (mpz_srcptr);


               void *__gmpz_export (void *, size_t *, int, size_t, int, size_t, mpz_srcptr);


               void __gmpz_fac_ui (mpz_ptr, unsigned long int);


               void __gmpz_2fac_ui (mpz_ptr, unsigned long int);


               void __gmpz_mfac_uiui (mpz_ptr, unsigned long int, unsigned long int);


               void __gmpz_primorial_ui (mpz_ptr, unsigned long int);


               void __gmpz_fdiv_q (mpz_ptr, mpz_srcptr, mpz_srcptr);


               void __gmpz_fdiv_q_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);


               unsigned long int __gmpz_fdiv_q_ui (mpz_ptr, mpz_srcptr, unsigned long int);


               void __gmpz_fdiv_qr (mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr);


               unsigned long int __gmpz_fdiv_qr_ui (mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int);


               void __gmpz_fdiv_r (mpz_ptr, mpz_srcptr, mpz_srcptr);


               void __gmpz_fdiv_r_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);


               unsigned long int __gmpz_fdiv_r_ui (mpz_ptr, mpz_srcptr, unsigned long int);


               unsigned long int __gmpz_fdiv_ui (mpz_srcptr, unsigned long int) __attribute__ ((__pure__));


               void __gmpz_fib_ui (mpz_ptr, unsigned long int);


               void __gmpz_fib2_ui (mpz_ptr, mpz_ptr, unsigned long int);


               int __gmpz_fits_sint_p (mpz_srcptr) __attribute__ ((__pure__));


               int __gmpz_fits_slong_p (mpz_srcptr) __attribute__ ((__pure__));


               int __gmpz_fits_sshort_p (mpz_srcptr) __attribute__ ((__pure__));



               int __gmpz_fits_uint_p (mpz_srcptr) __attribute__ ((__pure__));




               int __gmpz_fits_ulong_p (mpz_srcptr) __attribute__ ((__pure__));




               int __gmpz_fits_ushort_p (mpz_srcptr) __attribute__ ((__pure__));



               void __gmpz_gcd (mpz_ptr, mpz_srcptr, mpz_srcptr);


               unsigned long int __gmpz_gcd_ui (mpz_ptr, mpz_srcptr, unsigned long int);


               void __gmpz_gcdext (mpz_ptr, mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr);


               double __gmpz_get_d (mpz_srcptr) __attribute__ ((__pure__));


               double __gmpz_get_d_2exp (signed long int *, mpz_srcptr);


                            long int __gmpz_get_si (mpz_srcptr) __attribute__ ((__pure__));


               char *__gmpz_get_str (char *, int, mpz_srcptr);



               unsigned long int __gmpz_get_ui (mpz_srcptr) __attribute__ ((__pure__));




               mp_limb_t __gmpz_getlimbn (mpz_srcptr, mp_size_t) __attribute__ ((__pure__));



               mp_bitcnt_t __gmpz_hamdist (mpz_srcptr, mpz_srcptr) __attribute__ ((__pure__));


               void __gmpz_import (mpz_ptr, size_t, int, size_t, int, size_t, const void *);


               void __gmpz_init (mpz_ptr) ;


               void __gmpz_init2 (mpz_ptr, mp_bitcnt_t);


               void __gmpz_inits (mpz_ptr, ...) ;


               void __gmpz_init_set (mpz_ptr, mpz_srcptr);


               void __gmpz_init_set_d (mpz_ptr, double);


               void __gmpz_init_set_si (mpz_ptr, signed long int);


               int __gmpz_init_set_str (mpz_ptr, const char *, int);


               void __gmpz_init_set_ui (mpz_ptr, unsigned long int);
# 890 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
               int __gmpz_invert (mpz_ptr, mpz_srcptr, mpz_srcptr);


               void __gmpz_ior (mpz_ptr, mpz_srcptr, mpz_srcptr);


               int __gmpz_jacobi (mpz_srcptr, mpz_srcptr) __attribute__ ((__pure__));




               int __gmpz_kronecker_si (mpz_srcptr, long) __attribute__ ((__pure__));


               int __gmpz_kronecker_ui (mpz_srcptr, unsigned long) __attribute__ ((__pure__));


               int __gmpz_si_kronecker (long, mpz_srcptr) __attribute__ ((__pure__));


               int __gmpz_ui_kronecker (unsigned long, mpz_srcptr) __attribute__ ((__pure__));


               void __gmpz_lcm (mpz_ptr, mpz_srcptr, mpz_srcptr);


               void __gmpz_lcm_ui (mpz_ptr, mpz_srcptr, unsigned long);




               void __gmpz_lucnum_ui (mpz_ptr, unsigned long int);


               void __gmpz_lucnum2_ui (mpz_ptr, mpz_ptr, unsigned long int);


               int __gmpz_millerrabin (mpz_srcptr, int) __attribute__ ((__pure__));


               void __gmpz_mod (mpz_ptr, mpz_srcptr, mpz_srcptr);




               void __gmpz_mul (mpz_ptr, mpz_srcptr, mpz_srcptr);


               void __gmpz_mul_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);


               void __gmpz_mul_si (mpz_ptr, mpz_srcptr, long int);


               void __gmpz_mul_ui (mpz_ptr, mpz_srcptr, unsigned long int);



               void __gmpz_neg (mpz_ptr, mpz_srcptr);



               void __gmpz_nextprime (mpz_ptr, mpz_srcptr);


               int __gmpz_prevprime (mpz_ptr, mpz_srcptr);
# 968 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
               int __gmpz_perfect_power_p (mpz_srcptr) __attribute__ ((__pure__));



               int __gmpz_perfect_square_p (mpz_srcptr) __attribute__ ((__pure__));




               mp_bitcnt_t __gmpz_popcount (mpz_srcptr) __attribute__ ((__pure__));



               void __gmpz_pow_ui (mpz_ptr, mpz_srcptr, unsigned long int);


               void __gmpz_powm (mpz_ptr, mpz_srcptr, mpz_srcptr, mpz_srcptr);


               void __gmpz_powm_sec (mpz_ptr, mpz_srcptr, mpz_srcptr, mpz_srcptr);


               void __gmpz_powm_ui (mpz_ptr, mpz_srcptr, unsigned long int, mpz_srcptr);


               int __gmpz_probab_prime_p (mpz_srcptr, int) __attribute__ ((__pure__));


               void __gmpz_random (mpz_ptr, mp_size_t);


               void __gmpz_random2 (mpz_ptr, mp_size_t);


               void __gmpz_realloc2 (mpz_ptr, mp_bitcnt_t);


               mp_bitcnt_t __gmpz_remove (mpz_ptr, mpz_srcptr, mpz_srcptr);


               int __gmpz_root (mpz_ptr, mpz_srcptr, unsigned long int);


               void __gmpz_rootrem (mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int);


               void __gmpz_rrandomb (mpz_ptr, gmp_randstate_ptr, mp_bitcnt_t);


               mp_bitcnt_t __gmpz_scan0 (mpz_srcptr, mp_bitcnt_t) __attribute__ ((__pure__));


               mp_bitcnt_t __gmpz_scan1 (mpz_srcptr, mp_bitcnt_t) __attribute__ ((__pure__));


               void __gmpz_set (mpz_ptr, mpz_srcptr);


               void __gmpz_set_d (mpz_ptr, double);


               void __gmpz_set_f (mpz_ptr, mpf_srcptr);



               void __gmpz_set_q (mpz_ptr, mpq_srcptr);



               void __gmpz_set_si (mpz_ptr, signed long int);


               int __gmpz_set_str (mpz_ptr, const char *, int);


               void __gmpz_set_ui (mpz_ptr, unsigned long int);


               void __gmpz_setbit (mpz_ptr, mp_bitcnt_t);



               size_t __gmpz_size (mpz_srcptr) __attribute__ ((__pure__));



               size_t __gmpz_sizeinbase (mpz_srcptr, int) __attribute__ ((__pure__));


               void __gmpz_sqrt (mpz_ptr, mpz_srcptr);


               void __gmpz_sqrtrem (mpz_ptr, mpz_ptr, mpz_srcptr);


               void __gmpz_sub (mpz_ptr, mpz_srcptr, mpz_srcptr);


               void __gmpz_sub_ui (mpz_ptr, mpz_srcptr, unsigned long int);


               void __gmpz_ui_sub (mpz_ptr, unsigned long int, mpz_srcptr);


               void __gmpz_submul (mpz_ptr, mpz_srcptr, mpz_srcptr);


               void __gmpz_submul_ui (mpz_ptr, mpz_srcptr, unsigned long int);


               void __gmpz_swap (mpz_ptr, mpz_ptr) ;


               unsigned long int __gmpz_tdiv_ui (mpz_srcptr, unsigned long int) __attribute__ ((__pure__));


               void __gmpz_tdiv_q (mpz_ptr, mpz_srcptr, mpz_srcptr);


               void __gmpz_tdiv_q_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);


               unsigned long int __gmpz_tdiv_q_ui (mpz_ptr, mpz_srcptr, unsigned long int);


               void __gmpz_tdiv_qr (mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr);


               unsigned long int __gmpz_tdiv_qr_ui (mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int);


               void __gmpz_tdiv_r (mpz_ptr, mpz_srcptr, mpz_srcptr);


               void __gmpz_tdiv_r_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);


               unsigned long int __gmpz_tdiv_r_ui (mpz_ptr, mpz_srcptr, unsigned long int);


               int __gmpz_tstbit (mpz_srcptr, mp_bitcnt_t) __attribute__ ((__pure__));


               void __gmpz_ui_pow_ui (mpz_ptr, unsigned long int, unsigned long int);


               void __gmpz_urandomb (mpz_ptr, gmp_randstate_ptr, mp_bitcnt_t);


               void __gmpz_urandomm (mpz_ptr, gmp_randstate_ptr, mpz_srcptr);



               void __gmpz_xor (mpz_ptr, mpz_srcptr, mpz_srcptr);


               mp_srcptr __gmpz_limbs_read (mpz_srcptr);


               mp_ptr __gmpz_limbs_write (mpz_ptr, mp_size_t);


               mp_ptr __gmpz_limbs_modify (mpz_ptr, mp_size_t);


               void __gmpz_limbs_finish (mpz_ptr, mp_size_t);


               mpz_srcptr __gmpz_roinit_n (mpz_ptr, mp_srcptr, mp_size_t);







               void __gmpq_abs (mpq_ptr, mpq_srcptr);



               void __gmpq_add (mpq_ptr, mpq_srcptr, mpq_srcptr);


               void __gmpq_canonicalize (mpq_ptr);


               void __gmpq_clear (mpq_ptr);


               void __gmpq_clears (mpq_ptr, ...);


               int __gmpq_cmp (mpq_srcptr, mpq_srcptr) __attribute__ ((__pure__));


               int __gmpq_cmp_si (mpq_srcptr, long, unsigned long) __attribute__ ((__pure__));


               int __gmpq_cmp_ui (mpq_srcptr, unsigned long int, unsigned long int) __attribute__ ((__pure__));


               int __gmpq_cmp_z (mpq_srcptr, mpz_srcptr) __attribute__ ((__pure__));


               void __gmpq_div (mpq_ptr, mpq_srcptr, mpq_srcptr);


               void __gmpq_div_2exp (mpq_ptr, mpq_srcptr, mp_bitcnt_t);


               int __gmpq_equal (mpq_srcptr, mpq_srcptr) __attribute__ ((__pure__));


               void __gmpq_get_num (mpz_ptr, mpq_srcptr);


               void __gmpq_get_den (mpz_ptr, mpq_srcptr);


               double __gmpq_get_d (mpq_srcptr) __attribute__ ((__pure__));


               char *__gmpq_get_str (char *, int, mpq_srcptr);


               void __gmpq_init (mpq_ptr);


               void __gmpq_inits (mpq_ptr, ...);







               void __gmpq_inv (mpq_ptr, mpq_srcptr);


               void __gmpq_mul (mpq_ptr, mpq_srcptr, mpq_srcptr);


               void __gmpq_mul_2exp (mpq_ptr, mpq_srcptr, mp_bitcnt_t);



               void __gmpq_neg (mpq_ptr, mpq_srcptr);
# 1223 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
               void __gmpq_set (mpq_ptr, mpq_srcptr);


               void __gmpq_set_d (mpq_ptr, double);


               void __gmpq_set_den (mpq_ptr, mpz_srcptr);


               void __gmpq_set_f (mpq_ptr, mpf_srcptr);


               void __gmpq_set_num (mpq_ptr, mpz_srcptr);


               void __gmpq_set_si (mpq_ptr, signed long int, unsigned long int);


               int __gmpq_set_str (mpq_ptr, const char *, int);


               void __gmpq_set_ui (mpq_ptr, unsigned long int, unsigned long int);


               void __gmpq_set_z (mpq_ptr, mpz_srcptr);


               void __gmpq_sub (mpq_ptr, mpq_srcptr, mpq_srcptr);


               void __gmpq_swap (mpq_ptr, mpq_ptr) ;





               void __gmpf_abs (mpf_ptr, mpf_srcptr);


               void __gmpf_add (mpf_ptr, mpf_srcptr, mpf_srcptr);


               void __gmpf_add_ui (mpf_ptr, mpf_srcptr, unsigned long int);

               void __gmpf_ceil (mpf_ptr, mpf_srcptr);


               void __gmpf_clear (mpf_ptr);


               void __gmpf_clears (mpf_ptr, ...);


               int __gmpf_cmp (mpf_srcptr, mpf_srcptr) __attribute__ ((__pure__));


               int __gmpf_cmp_z (mpf_srcptr, mpz_srcptr) __attribute__ ((__pure__));


               int __gmpf_cmp_d (mpf_srcptr, double) __attribute__ ((__pure__));


               int __gmpf_cmp_si (mpf_srcptr, signed long int) __attribute__ ((__pure__));


               int __gmpf_cmp_ui (mpf_srcptr, unsigned long int) __attribute__ ((__pure__));


               void __gmpf_div (mpf_ptr, mpf_srcptr, mpf_srcptr);


               void __gmpf_div_2exp (mpf_ptr, mpf_srcptr, mp_bitcnt_t);


               void __gmpf_div_ui (mpf_ptr, mpf_srcptr, unsigned long int);


               void __gmpf_dump (mpf_srcptr);


               int __gmpf_eq (mpf_srcptr, mpf_srcptr, mp_bitcnt_t) __attribute__ ((__pure__));


               int __gmpf_fits_sint_p (mpf_srcptr) __attribute__ ((__pure__));


               int __gmpf_fits_slong_p (mpf_srcptr) __attribute__ ((__pure__));


               int __gmpf_fits_sshort_p (mpf_srcptr) __attribute__ ((__pure__));


               int __gmpf_fits_uint_p (mpf_srcptr) __attribute__ ((__pure__));


               int __gmpf_fits_ulong_p (mpf_srcptr) __attribute__ ((__pure__));


               int __gmpf_fits_ushort_p (mpf_srcptr) __attribute__ ((__pure__));


               void __gmpf_floor (mpf_ptr, mpf_srcptr);


               double __gmpf_get_d (mpf_srcptr) __attribute__ ((__pure__));


               double __gmpf_get_d_2exp (signed long int *, mpf_srcptr);


               mp_bitcnt_t __gmpf_get_default_prec (void) __attribute__ ((__pure__));


               mp_bitcnt_t __gmpf_get_prec (mpf_srcptr) __attribute__ ((__pure__));


               long __gmpf_get_si (mpf_srcptr) __attribute__ ((__pure__));


               char *__gmpf_get_str (char *, mp_exp_t *, int, size_t, mpf_srcptr);


               unsigned long __gmpf_get_ui (mpf_srcptr) __attribute__ ((__pure__));


               void __gmpf_init (mpf_ptr);


               void __gmpf_init2 (mpf_ptr, mp_bitcnt_t);


               void __gmpf_inits (mpf_ptr, ...);


               void __gmpf_init_set (mpf_ptr, mpf_srcptr);


               void __gmpf_init_set_d (mpf_ptr, double);


               void __gmpf_init_set_si (mpf_ptr, signed long int);


               int __gmpf_init_set_str (mpf_ptr, const char *, int);


               void __gmpf_init_set_ui (mpf_ptr, unsigned long int);







               int __gmpf_integer_p (mpf_srcptr) __attribute__ ((__pure__));


               void __gmpf_mul (mpf_ptr, mpf_srcptr, mpf_srcptr);


               void __gmpf_mul_2exp (mpf_ptr, mpf_srcptr, mp_bitcnt_t);


               void __gmpf_mul_ui (mpf_ptr, mpf_srcptr, unsigned long int);


               void __gmpf_neg (mpf_ptr, mpf_srcptr);







               void __gmpf_pow_ui (mpf_ptr, mpf_srcptr, unsigned long int);


               void __gmpf_random2 (mpf_ptr, mp_size_t, mp_exp_t);


               void __gmpf_reldiff (mpf_ptr, mpf_srcptr, mpf_srcptr);


               void __gmpf_set (mpf_ptr, mpf_srcptr);


               void __gmpf_set_d (mpf_ptr, double);


               void __gmpf_set_default_prec (mp_bitcnt_t) ;


               void __gmpf_set_prec (mpf_ptr, mp_bitcnt_t);


               void __gmpf_set_prec_raw (mpf_ptr, mp_bitcnt_t) ;


               void __gmpf_set_q (mpf_ptr, mpq_srcptr);


               void __gmpf_set_si (mpf_ptr, signed long int);


               int __gmpf_set_str (mpf_ptr, const char *, int);


               void __gmpf_set_ui (mpf_ptr, unsigned long int);


               void __gmpf_set_z (mpf_ptr, mpz_srcptr);


               size_t __gmpf_size (mpf_srcptr) __attribute__ ((__pure__));


               void __gmpf_sqrt (mpf_ptr, mpf_srcptr);


               void __gmpf_sqrt_ui (mpf_ptr, unsigned long int);


               void __gmpf_sub (mpf_ptr, mpf_srcptr, mpf_srcptr);


               void __gmpf_sub_ui (mpf_ptr, mpf_srcptr, unsigned long int);


               void __gmpf_swap (mpf_ptr, mpf_ptr) ;


               void __gmpf_trunc (mpf_ptr, mpf_srcptr);


               void __gmpf_ui_div (mpf_ptr, unsigned long int, mpf_srcptr);


               void __gmpf_ui_sub (mpf_ptr, unsigned long int, mpf_srcptr);


               void __gmpf_urandomb (mpf_ptr, gmp_randstate_ptr, mp_bitcnt_t);
# 1472 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
               mp_limb_t __gmpn_add (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);




               mp_limb_t __gmpn_add_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t) ;



               mp_limb_t __gmpn_add_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);


               mp_limb_t __gmpn_addmul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);



               int __gmpn_cmp (mp_srcptr, mp_srcptr, mp_size_t) __attribute__ ((__pure__));




               int __gmpn_zero_p (mp_srcptr, mp_size_t) __attribute__ ((__pure__));



               void __gmpn_divexact_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);





               mp_limb_t __gmpn_divexact_by3c (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);





               mp_limb_t __gmpn_divrem (mp_ptr, mp_size_t, mp_ptr, mp_size_t, mp_srcptr, mp_size_t);


               mp_limb_t __gmpn_divrem_1 (mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_limb_t);


               mp_limb_t __gmpn_divrem_2 (mp_ptr, mp_size_t, mp_ptr, mp_size_t, mp_srcptr);


               mp_limb_t __gmpn_div_qr_1 (mp_ptr, mp_limb_t *, mp_srcptr, mp_size_t, mp_limb_t);


               mp_limb_t __gmpn_div_qr_2 (mp_ptr, mp_ptr, mp_srcptr, mp_size_t, mp_srcptr);


               mp_size_t __gmpn_gcd (mp_ptr, mp_ptr, mp_size_t, mp_ptr, mp_size_t);


               mp_limb_t __gmpn_gcd_11 (mp_limb_t, mp_limb_t) __attribute__ ((__pure__));


               mp_limb_t __gmpn_gcd_1 (mp_srcptr, mp_size_t, mp_limb_t) __attribute__ ((__pure__));


               mp_limb_t __gmpn_gcdext_1 (mp_limb_signed_t *, mp_limb_signed_t *, mp_limb_t, mp_limb_t);


               mp_size_t __gmpn_gcdext (mp_ptr, mp_ptr, mp_size_t *, mp_ptr, mp_size_t, mp_ptr, mp_size_t);


               size_t __gmpn_get_str (unsigned char *, int, mp_ptr, mp_size_t);


               mp_bitcnt_t __gmpn_hamdist (mp_srcptr, mp_srcptr, mp_size_t) __attribute__ ((__pure__));


               mp_limb_t __gmpn_lshift (mp_ptr, mp_srcptr, mp_size_t, unsigned int);


               mp_limb_t __gmpn_mod_1 (mp_srcptr, mp_size_t, mp_limb_t) __attribute__ ((__pure__));


               mp_limb_t __gmpn_mul (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);


               mp_limb_t __gmpn_mul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);


               void __gmpn_mul_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);


               void __gmpn_sqr (mp_ptr, mp_srcptr, mp_size_t);



               mp_limb_t __gmpn_neg (mp_ptr, mp_srcptr, mp_size_t);



               void __gmpn_com (mp_ptr, mp_srcptr, mp_size_t);


               int __gmpn_perfect_square_p (mp_srcptr, mp_size_t) __attribute__ ((__pure__));


               int __gmpn_perfect_power_p (mp_srcptr, mp_size_t) __attribute__ ((__pure__));


               mp_bitcnt_t __gmpn_popcount (mp_srcptr, mp_size_t) __attribute__ ((__pure__));


               mp_size_t __gmpn_pow_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t, mp_ptr);



               mp_limb_t __gmpn_preinv_mod_1 (mp_srcptr, mp_size_t, mp_limb_t, mp_limb_t) __attribute__ ((__pure__));


               void __gmpn_random (mp_ptr, mp_size_t);


               void __gmpn_random2 (mp_ptr, mp_size_t);


               mp_limb_t __gmpn_rshift (mp_ptr, mp_srcptr, mp_size_t, unsigned int);


               mp_bitcnt_t __gmpn_scan0 (mp_srcptr, mp_bitcnt_t) __attribute__ ((__pure__));


               mp_bitcnt_t __gmpn_scan1 (mp_srcptr, mp_bitcnt_t) __attribute__ ((__pure__));


               mp_size_t __gmpn_set_str (mp_ptr, const unsigned char *, size_t, int);


               size_t __gmpn_sizeinbase (mp_srcptr, mp_size_t, int);


               mp_size_t __gmpn_sqrtrem (mp_ptr, mp_ptr, mp_srcptr, mp_size_t);



               mp_limb_t __gmpn_sub (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);




               mp_limb_t __gmpn_sub_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t) ;



               mp_limb_t __gmpn_sub_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);


               mp_limb_t __gmpn_submul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);


               void __gmpn_tdiv_qr (mp_ptr, mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);


               void __gmpn_and_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);

               void __gmpn_andn_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);

               void __gmpn_nand_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);

               void __gmpn_ior_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);

               void __gmpn_iorn_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);

               void __gmpn_nior_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);

               void __gmpn_xor_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);

               void __gmpn_xnor_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);


               void __gmpn_copyi (mp_ptr, mp_srcptr, mp_size_t);

               void __gmpn_copyd (mp_ptr, mp_srcptr, mp_size_t);

               void __gmpn_zero (mp_ptr, mp_size_t);


               mp_limb_t __gmpn_cnd_add_n (mp_limb_t, mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);

               mp_limb_t __gmpn_cnd_sub_n (mp_limb_t, mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);


               mp_limb_t __gmpn_sec_add_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t, mp_ptr);

               mp_size_t __gmpn_sec_add_1_itch (mp_size_t) __attribute__ ((__pure__));


               mp_limb_t __gmpn_sec_sub_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t, mp_ptr);

               mp_size_t __gmpn_sec_sub_1_itch (mp_size_t) __attribute__ ((__pure__));


               void __gmpn_cnd_swap (mp_limb_t, volatile mp_limb_t *, volatile mp_limb_t *, mp_size_t);


               void __gmpn_sec_mul (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t, mp_ptr);

               mp_size_t __gmpn_sec_mul_itch (mp_size_t, mp_size_t) __attribute__ ((__pure__));


               void __gmpn_sec_sqr (mp_ptr, mp_srcptr, mp_size_t, mp_ptr);

               mp_size_t __gmpn_sec_sqr_itch (mp_size_t) __attribute__ ((__pure__));


               void __gmpn_sec_powm (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_bitcnt_t, mp_srcptr, mp_size_t, mp_ptr);

               mp_size_t __gmpn_sec_powm_itch (mp_size_t, mp_bitcnt_t, mp_size_t) __attribute__ ((__pure__));


               void __gmpn_sec_tabselect (volatile mp_limb_t *, volatile const mp_limb_t *, mp_size_t, mp_size_t, mp_size_t);


               mp_limb_t __gmpn_sec_div_qr (mp_ptr, mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_ptr);

               mp_size_t __gmpn_sec_div_qr_itch (mp_size_t, mp_size_t) __attribute__ ((__pure__));

               void __gmpn_sec_div_r (mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_ptr);

               mp_size_t __gmpn_sec_div_r_itch (mp_size_t, mp_size_t) __attribute__ ((__pure__));


               int __gmpn_sec_invert (mp_ptr, mp_ptr, mp_srcptr, mp_size_t, mp_bitcnt_t, mp_ptr);

               mp_size_t __gmpn_sec_invert_itch (mp_size_t) __attribute__ ((__pure__));
# 1721 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
extern __inline__ __attribute__ ((__gnu_inline__)) void
__gmpz_abs (mpz_ptr __gmp_w, mpz_srcptr __gmp_u)
{
  if (__gmp_w != __gmp_u)
    __gmpz_set (__gmp_w, __gmp_u);
  __gmp_w->_mp_size = ((__gmp_w->_mp_size) >= 0 ? (__gmp_w->_mp_size) : -(__gmp_w->_mp_size));
}
# 1745 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
extern __inline__ __attribute__ ((__gnu_inline__))

int
__gmpz_fits_uint_p (mpz_srcptr __gmp_z)
{
  mp_size_t __gmp_n = __gmp_z->_mp_size; mp_ptr __gmp_p = __gmp_z->_mp_d; return (__gmp_n == 0 || (__gmp_n == 1 && __gmp_p[0] <= (2147483647 *2U +1U)));;
}




extern __inline__ __attribute__ ((__gnu_inline__))

int
__gmpz_fits_ulong_p (mpz_srcptr __gmp_z)
{
  mp_size_t __gmp_n = __gmp_z->_mp_size; mp_ptr __gmp_p = __gmp_z->_mp_d; return (__gmp_n == 0 || (__gmp_n == 1 && __gmp_p[0] <= (9223372036854775807L *2UL+1UL)));;
}




extern __inline__ __attribute__ ((__gnu_inline__))

int
__gmpz_fits_ushort_p (mpz_srcptr __gmp_z)
{
  mp_size_t __gmp_n = __gmp_z->_mp_size; mp_ptr __gmp_p = __gmp_z->_mp_d; return (__gmp_n == 0 || (__gmp_n == 1 && __gmp_p[0] <= (32767 * 2 + 1)));;
}




extern __inline__ __attribute__ ((__gnu_inline__))

unsigned long
__gmpz_get_ui (mpz_srcptr __gmp_z)
{
  mp_ptr __gmp_p = __gmp_z->_mp_d;
  mp_size_t __gmp_n = __gmp_z->_mp_size;
  mp_limb_t __gmp_l = __gmp_p[0];






  return (__gmp_n != 0 ? __gmp_l : 0);
# 1801 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
}




extern __inline__ __attribute__ ((__gnu_inline__))

mp_limb_t
__gmpz_getlimbn (mpz_srcptr __gmp_z, mp_size_t __gmp_n)
{
  mp_limb_t __gmp_result = 0;
  if (__builtin_expect ((__gmp_n >= 0 && __gmp_n < ((__gmp_z->_mp_size) >= 0 ? (__gmp_z->_mp_size) : -(__gmp_z->_mp_size))) != 0, 1))
    __gmp_result = __gmp_z->_mp_d[__gmp_n];
  return __gmp_result;
}



extern __inline__ __attribute__ ((__gnu_inline__)) void
__gmpz_neg (mpz_ptr __gmp_w, mpz_srcptr __gmp_u)
{
  if (__gmp_w != __gmp_u)
    __gmpz_set (__gmp_w, __gmp_u);
  __gmp_w->_mp_size = - __gmp_w->_mp_size;
}




extern __inline__ __attribute__ ((__gnu_inline__))

int
__gmpz_perfect_square_p (mpz_srcptr __gmp_a)
{
  mp_size_t __gmp_asize;
  int __gmp_result;

  __gmp_asize = __gmp_a->_mp_size;
  __gmp_result = (__gmp_asize >= 0);
  if (__builtin_expect ((__gmp_asize > 0) != 0, 1))
    __gmp_result = __gmpn_perfect_square_p (__gmp_a->_mp_d, __gmp_asize);
  return __gmp_result;
}




extern __inline__ __attribute__ ((__gnu_inline__))

mp_bitcnt_t
__gmpz_popcount (mpz_srcptr __gmp_u)
{
  mp_size_t __gmp_usize;
  mp_bitcnt_t __gmp_result;

  __gmp_usize = __gmp_u->_mp_size;
  __gmp_result = (__gmp_usize < 0 ? ~ ((mp_bitcnt_t) (0)) : ((mp_bitcnt_t) (0)));
  if (__builtin_expect ((__gmp_usize > 0) != 0, 1))
    __gmp_result = __gmpn_popcount (__gmp_u->_mp_d, __gmp_usize);
  return __gmp_result;
}




extern __inline__ __attribute__ ((__gnu_inline__))

void
__gmpz_set_q (mpz_ptr __gmp_w, mpq_srcptr __gmp_u)
{
  __gmpz_tdiv_q (__gmp_w, (&((__gmp_u)->_mp_num)), (&((__gmp_u)->_mp_den)));
}




extern __inline__ __attribute__ ((__gnu_inline__))

size_t
__gmpz_size (mpz_srcptr __gmp_z)
{
  return ((__gmp_z->_mp_size) >= 0 ? (__gmp_z->_mp_size) : -(__gmp_z->_mp_size));
}






extern __inline__ __attribute__ ((__gnu_inline__)) void
__gmpq_abs (mpq_ptr __gmp_w, mpq_srcptr __gmp_u)
{
  if (__gmp_w != __gmp_u)
    __gmpq_set (__gmp_w, __gmp_u);
  __gmp_w->_mp_num._mp_size = ((__gmp_w->_mp_num._mp_size) >= 0 ? (__gmp_w->_mp_num._mp_size) : -(__gmp_w->_mp_num._mp_size));
}



extern __inline__ __attribute__ ((__gnu_inline__)) void
__gmpq_neg (mpq_ptr __gmp_w, mpq_srcptr __gmp_u)
{
  if (__gmp_w != __gmp_u)
    __gmpq_set (__gmp_w, __gmp_u);
  __gmp_w->_mp_num._mp_size = - __gmp_w->_mp_num._mp_size;
}
# 2143 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
extern __inline__ __attribute__ ((__gnu_inline__))

mp_limb_t
__gmpn_add (mp_ptr __gmp_wp, mp_srcptr __gmp_xp, mp_size_t __gmp_xsize, mp_srcptr __gmp_yp, mp_size_t __gmp_ysize)
{
  mp_limb_t __gmp_c;
  do { mp_size_t __gmp_i; mp_limb_t __gmp_x; __gmp_i = (__gmp_ysize); if (__gmp_i != 0) { if (__gmpn_add_n (__gmp_wp, __gmp_xp, __gmp_yp, __gmp_i)) { do { if (__gmp_i >= (__gmp_xsize)) { (__gmp_c) = 1; goto __gmp_done; } __gmp_x = (__gmp_xp)[__gmp_i]; } while ((((__gmp_wp)[__gmp_i++] = (__gmp_x + 1) & ((~ ((mp_limb_t) (0))) >> 0)) == 0)); } } if ((__gmp_wp) != (__gmp_xp)) do { mp_size_t __gmp_j; ; for (__gmp_j = (__gmp_i); __gmp_j < (__gmp_xsize); __gmp_j++) (__gmp_wp)[__gmp_j] = (__gmp_xp)[__gmp_j]; } while (0); (__gmp_c) = 0; __gmp_done: ; } while (0);
  return __gmp_c;
}




extern __inline__ __attribute__ ((__gnu_inline__))

mp_limb_t
__gmpn_add_1 (mp_ptr __gmp_dst, mp_srcptr __gmp_src, mp_size_t __gmp_size, mp_limb_t __gmp_n)
{
  mp_limb_t __gmp_c;
  do { mp_size_t __gmp_i; mp_limb_t __gmp_x, __gmp_r; __gmp_x = (__gmp_src)[0]; __gmp_r = __gmp_x + (__gmp_n); (__gmp_dst)[0] = __gmp_r; if (((__gmp_r) < ((__gmp_n)))) { (__gmp_c) = 1; for (__gmp_i = 1; __gmp_i < (__gmp_size);) { __gmp_x = (__gmp_src)[__gmp_i]; __gmp_r = __gmp_x + 1; (__gmp_dst)[__gmp_i] = __gmp_r; ++__gmp_i; if (!((__gmp_r) < (1))) { if ((__gmp_src) != (__gmp_dst)) do { mp_size_t __gmp_j; ; for (__gmp_j = (__gmp_i); __gmp_j < (__gmp_size); __gmp_j++) (__gmp_dst)[__gmp_j] = (__gmp_src)[__gmp_j]; } while (0); (__gmp_c) = 0; break; } } } else { if ((__gmp_src) != (__gmp_dst)) do { mp_size_t __gmp_j; ; for (__gmp_j = (1); __gmp_j < (__gmp_size); __gmp_j++) (__gmp_dst)[__gmp_j] = (__gmp_src)[__gmp_j]; } while (0); (__gmp_c) = 0; } } while (0);
  return __gmp_c;
}




extern __inline__ __attribute__ ((__gnu_inline__))

int
__gmpn_cmp (mp_srcptr __gmp_xp, mp_srcptr __gmp_yp, mp_size_t __gmp_size)
{
  int __gmp_result;
  do { mp_size_t __gmp_i; mp_limb_t __gmp_x, __gmp_y; (__gmp_result) = 0; __gmp_i = (__gmp_size); while (--__gmp_i >= 0) { __gmp_x = (__gmp_xp)[__gmp_i]; __gmp_y = (__gmp_yp)[__gmp_i]; if (__gmp_x != __gmp_y) { (__gmp_result) = (__gmp_x > __gmp_y ? 1 : -1); break; } } } while (0);
  return __gmp_result;
}




extern __inline__ __attribute__ ((__gnu_inline__))

int
__gmpn_zero_p (mp_srcptr __gmp_p, mp_size_t __gmp_n)
{

    do {
      if (__gmp_p[--__gmp_n] != 0)
 return 0;
    } while (__gmp_n != 0);
  return 1;
}




extern __inline__ __attribute__ ((__gnu_inline__))

mp_limb_t
__gmpn_sub (mp_ptr __gmp_wp, mp_srcptr __gmp_xp, mp_size_t __gmp_xsize, mp_srcptr __gmp_yp, mp_size_t __gmp_ysize)
{
  mp_limb_t __gmp_c;
  do { mp_size_t __gmp_i; mp_limb_t __gmp_x; __gmp_i = (__gmp_ysize); if (__gmp_i != 0) { if (__gmpn_sub_n (__gmp_wp, __gmp_xp, __gmp_yp, __gmp_i)) { do { if (__gmp_i >= (__gmp_xsize)) { (__gmp_c) = 1; goto __gmp_done; } __gmp_x = (__gmp_xp)[__gmp_i]; } while ((((__gmp_wp)[__gmp_i++] = (__gmp_x - 1) & ((~ ((mp_limb_t) (0))) >> 0)), __gmp_x == 0)); } } if ((__gmp_wp) != (__gmp_xp)) do { mp_size_t __gmp_j; ; for (__gmp_j = (__gmp_i); __gmp_j < (__gmp_xsize); __gmp_j++) (__gmp_wp)[__gmp_j] = (__gmp_xp)[__gmp_j]; } while (0); (__gmp_c) = 0; __gmp_done: ; } while (0);
  return __gmp_c;
}




extern __inline__ __attribute__ ((__gnu_inline__))

mp_limb_t
__gmpn_sub_1 (mp_ptr __gmp_dst, mp_srcptr __gmp_src, mp_size_t __gmp_size, mp_limb_t __gmp_n)
{
  mp_limb_t __gmp_c;
  do { mp_size_t __gmp_i; mp_limb_t __gmp_x, __gmp_r; __gmp_x = (__gmp_src)[0]; __gmp_r = __gmp_x - (__gmp_n); (__gmp_dst)[0] = __gmp_r; if (((__gmp_x) < ((__gmp_n)))) { (__gmp_c) = 1; for (__gmp_i = 1; __gmp_i < (__gmp_size);) { __gmp_x = (__gmp_src)[__gmp_i]; __gmp_r = __gmp_x - 1; (__gmp_dst)[__gmp_i] = __gmp_r; ++__gmp_i; if (!((__gmp_x) < (1))) { if ((__gmp_src) != (__gmp_dst)) do { mp_size_t __gmp_j; ; for (__gmp_j = (__gmp_i); __gmp_j < (__gmp_size); __gmp_j++) (__gmp_dst)[__gmp_j] = (__gmp_src)[__gmp_j]; } while (0); (__gmp_c) = 0; break; } } } else { if ((__gmp_src) != (__gmp_dst)) do { mp_size_t __gmp_j; ; for (__gmp_j = (1); __gmp_j < (__gmp_size); __gmp_j++) (__gmp_dst)[__gmp_j] = (__gmp_src)[__gmp_j]; } while (0); (__gmp_c) = 0; } } while (0);
  return __gmp_c;
}




extern __inline__ __attribute__ ((__gnu_inline__))

mp_limb_t
__gmpn_neg (mp_ptr __gmp_rp, mp_srcptr __gmp_up, mp_size_t __gmp_n)
{
  while (*__gmp_up == 0)
    {
      *__gmp_rp = 0;
      if (!--__gmp_n)
 return 0;
      ++__gmp_up; ++__gmp_rp;
    }

  *__gmp_rp = (- *__gmp_up) & ((~ ((mp_limb_t) (0))) >> 0);

  if (--__gmp_n)
    __gmpn_com (++__gmp_rp, ++__gmp_up, __gmp_n);

  return 1;
}
# 2323 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
enum
{
  GMP_ERROR_NONE = 0,
  GMP_ERROR_UNSUPPORTED_ARGUMENT = 1,
  GMP_ERROR_DIVISION_BY_ZERO = 2,
  GMP_ERROR_SQRT_OF_NEGATIVE = 4,
  GMP_ERROR_INVALID_ARGUMENT = 8,
  GMP_ERROR_MPZ_OVERFLOW = 16
};
# 30 "./mpint.h" 2




typedef MP_INT mpint_t;




static inline unsigned long mpint_estimate_bits(const mpint_t *t)
{
 return (unsigned long)__gmpz_size(t) * (64 - 0);
}

static inline _Bool mpint_alloc_mayfail(mpint_t *t, unsigned long bits, ajla_error_t __attribute__((__unused__)) *err)
{
 __gmpz_init2(t, bits);
 return 1;
}

static inline _Bool mpint_alloc_copy_mayfail(mpint_t *t, const mpint_t *src, ajla_error_t __attribute__((__unused__)) *err)
{
 __gmpz_init_set(t, src);
 return 1;
}

static inline void mpint_free(mpint_t *t)
{
 __gmpz_clear(t);
}

static inline _Bool mpint_negative(const mpint_t *t)
{
 return ((t)->_mp_size < 0 ? -1 : (t)->_mp_size > 0) < 0;
}
# 157 "./mpint.h"
static inline _Bool mpint_set_from_int8_t(mpint_t *t, int8_t val, _Bool uns, ajla_error_t __attribute__((__unused__)) *err){ if (sizeof(int8_t) <= sizeof(long)) { if (!uns) __gmpz_set_si(t, (long)val); else __gmpz_set_ui(t, (unsigned long)(uint8_t)val); } else { _Bool sign = val < 0 && !uns; if ((__builtin_expect((int)(sign), 0))) val = -(uint8_t)val; __gmpz_import(t, 1, 1, sizeof(int8_t), 0, 0, &val); if ((__builtin_expect((int)(sign), 0))) __gmpz_neg(t, t); } return 1; } static inline _Bool mpint_init_from_int8_t(mpint_t *t, int8_t val, ajla_error_t *err){ if (sizeof(int8_t) <= sizeof(long)) { __gmpz_init_set_si(t, (long)val); } else { if ((__builtin_expect((int)(!mpint_alloc_mayfail(t, sizeof(int8_t) * 8, err)), 0))) return 0; if ((__builtin_expect((int)(!mpint_set_from_int8_t(t, val, 0, err)), 0))) { __gmpz_clear(t); return 0; } } return 1; } static inline __attribute__((__always_inline__)) _Bool mpint_export_to_int8_t(const mpint_t *t, int8_t *result, ajla_error_t *err){ if (__gmpz_fits_slong_p(t)) { long l; l = __gmpz_get_si(t); if ((__builtin_expect((int)(l != (int8_t)l), 0))) goto doesnt_fit; *result = (int8_t)l; return 1; } else if (sizeof(int8_t) > sizeof(long)) { uint8_t ui; size_t bit = __gmpz_sizeinbase(t, 2); if (bit > 8 * sizeof(int8_t)) goto doesnt_fit; (void)__gmpz_export(&ui, ((void*)0), 1, sizeof(uint8_t), 0, 0, t); if (((t)->_mp_size < 0 ? -1 : (t)->_mp_size > 0) >= 0) { if ((int8_t)ui < 0) goto doesnt_fit; } else { ui = -ui; if ((int8_t)ui >= 0) goto doesnt_fit; } *result = (int8_t)ui; return 1; } doesnt_fit: fatal_mayfail(error_ajla_aux_(1, 5, 0 , "./mpint.h" ":" "157"), err, "integer too large for the target type"); return 0; } static inline __attribute__((__always_inline__)) _Bool mpint_export_to_uint8_t(const mpint_t *t, uint8_t *result, ajla_error_t *err){ if (__gmpz_fits_ulong_p(t)) { unsigned long l; l = __gmpz_get_ui(t); if ((__builtin_expect((int)(l != (uint8_t)l), 0))) goto doesnt_fit; *result = (uint8_t)l; return 1; } else if (sizeof(uint8_t) > sizeof(unsigned long)) { size_t bit; if ((__builtin_expect((int)(((t)->_mp_size < 0 ? -1 : (t)->_mp_size > 0) < 0), 0))) goto doesnt_fit; bit = __gmpz_sizeinbase(t, 2); if (bit > 8 * sizeof(uint8_t)) goto doesnt_fit; (void)__gmpz_export(result, ((void*)0), 1, sizeof(uint8_t), 0, 0, t); return 1; } doesnt_fit: fatal_mayfail(error_ajla_aux_(1, 5, 0 , "./mpint.h" ":" "157"), err, "integer too large for the target type"); return 0; } static inline _Bool mpint_set_from_int16_t(mpint_t *t, int16_t val, _Bool uns, ajla_error_t __attribute__((__unused__)) *err){ if (sizeof(int16_t) <= sizeof(long)) { if (!uns) __gmpz_set_si(t, (long)val); else __gmpz_set_ui(t, (unsigned long)(uint16_t)val); } else { _Bool sign = val < 0 && !uns; if ((__builtin_expect((int)(sign), 0))) val = -(uint16_t)val; __gmpz_import(t, 1, 1, sizeof(int16_t), 0, 0, &val); if ((__builtin_expect((int)(sign), 0))) __gmpz_neg(t, t); } return 1; } static inline _Bool mpint_init_from_int16_t(mpint_t *t, int16_t val, ajla_error_t *err){ if (sizeof(int16_t) <= sizeof(long)) { __gmpz_init_set_si(t, (long)val); } else { if ((__builtin_expect((int)(!mpint_alloc_mayfail(t, sizeof(int16_t) * 8, err)), 0))) return 0; if ((__builtin_expect((int)(!mpint_set_from_int16_t(t, val, 0, err)), 0))) { __gmpz_clear(t); return 0; } } return 1; } static inline __attribute__((__always_inline__)) _Bool mpint_export_to_int16_t(const mpint_t *t, int16_t *result, ajla_error_t *err){ if (__gmpz_fits_slong_p(t)) { long l; l = __gmpz_get_si(t); if ((__builtin_expect((int)(l != (int16_t)l), 0))) goto doesnt_fit; *result = (int16_t)l; return 1; } else if (sizeof(int16_t) > sizeof(long)) { uint16_t ui; size_t bit = __gmpz_sizeinbase(t, 2); if (bit > 8 * sizeof(int16_t)) goto doesnt_fit; (void)__gmpz_export(&ui, ((void*)0), 1, sizeof(uint16_t), 0, 0, t); if (((t)->_mp_size < 0 ? -1 : (t)->_mp_size > 0) >= 0) { if ((int16_t)ui < 0) goto doesnt_fit; } else { ui = -ui; if ((int16_t)ui >= 0) goto doesnt_fit; } *result = (int16_t)ui; return 1; } doesnt_fit: fatal_mayfail(error_ajla_aux_(1, 5, 0 , "./mpint.h" ":" "157"), err, "integer too large for the target type"); return 0; } static inline __attribute__((__always_inline__)) _Bool mpint_export_to_uint16_t(const mpint_t *t, uint16_t *result, ajla_error_t *err){ if (__gmpz_fits_ulong_p(t)) { unsigned long l; l = __gmpz_get_ui(t); if ((__builtin_expect((int)(l != (uint16_t)l), 0))) goto doesnt_fit; *result = (uint16_t)l; return 1; } else if (sizeof(uint16_t) > sizeof(unsigned long)) { size_t bit; if ((__builtin_expect((int)(((t)->_mp_size < 0 ? -1 : (t)->_mp_size > 0) < 0), 0))) goto doesnt_fit; bit = __gmpz_sizeinbase(t, 2); if (bit > 8 * sizeof(uint16_t)) goto doesnt_fit; (void)__gmpz_export(result, ((void*)0), 1, sizeof(uint16_t), 0, 0, t); return 1; } doesnt_fit: fatal_mayfail(error_ajla_aux_(1, 5, 0 , "./mpint.h" ":" "157"), err, "integer too large for the target type"); return 0; } static inline _Bool mpint_set_from_int32_t(mpint_t *t, int32_t val, _Bool uns, ajla_error_t __attribute__((__unused__)) *err){ if (sizeof(int32_t) <= sizeof(long)) { if (!uns) __gmpz_set_si(t, (long)val); else __gmpz_set_ui(t, (unsigned long)(uint32_t)val); } else { _Bool sign = val < 0 && !uns; if ((__builtin_expect((int)(sign), 0))) val = -(uint32_t)val; __gmpz_import(t, 1, 1, sizeof(int32_t), 0, 0, &val); if ((__builtin_expect((int)(sign), 0))) __gmpz_neg(t, t); } return 1; } static inline _Bool mpint_init_from_int32_t(mpint_t *t, int32_t val, ajla_error_t *err){ if (sizeof(int32_t) <= sizeof(long)) { __gmpz_init_set_si(t, (long)val); } else { if ((__builtin_expect((int)(!mpint_alloc_mayfail(t, sizeof(int32_t) * 8, err)), 0))) return 0; if ((__builtin_expect((int)(!mpint_set_from_int32_t(t, val, 0, err)), 0))) { __gmpz_clear(t); return 0; } } return 1; } static inline __attribute__((__always_inline__)) _Bool mpint_export_to_int32_t(const mpint_t *t, int32_t *result, ajla_error_t *err){ if (__gmpz_fits_slong_p(t)) { long l; l = __gmpz_get_si(t); if ((__builtin_expect((int)(l != (int32_t)l), 0))) goto doesnt_fit; *result = (int32_t)l; return 1; } else if (sizeof(int32_t) > sizeof(long)) { uint32_t ui; size_t bit = __gmpz_sizeinbase(t, 2); if (bit > 8 * sizeof(int32_t)) goto doesnt_fit; (void)__gmpz_export(&ui, ((void*)0), 1, sizeof(uint32_t), 0, 0, t); if (((t)->_mp_size < 0 ? -1 : (t)->_mp_size > 0) >= 0) { if ((int32_t)ui < 0) goto doesnt_fit; } else { ui = -ui; if ((int32_t)ui >= 0) goto doesnt_fit; } *result = (int32_t)ui; return 1; } doesnt_fit: fatal_mayfail(error_ajla_aux_(1, 5, 0 , "./mpint.h" ":" "157"), err, "integer too large for the target type"); return 0; } static inline __attribute__((__always_inline__)) _Bool mpint_export_to_uint32_t(const mpint_t *t, uint32_t *result, ajla_error_t *err){ if (__gmpz_fits_ulong_p(t)) { unsigned long l; l = __gmpz_get_ui(t); if ((__builtin_expect((int)(l != (uint32_t)l), 0))) goto doesnt_fit; *result = (uint32_t)l; return 1; } else if (sizeof(uint32_t) > sizeof(unsigned long)) { size_t bit; if ((__builtin_expect((int)(((t)->_mp_size < 0 ? -1 : (t)->_mp_size > 0) < 0), 0))) goto doesnt_fit; bit = __gmpz_sizeinbase(t, 2); if (bit > 8 * sizeof(uint32_t)) goto doesnt_fit; (void)__gmpz_export(result, ((void*)0), 1, sizeof(uint32_t), 0, 0, t); return 1; } doesnt_fit: fatal_mayfail(error_ajla_aux_(1, 5, 0 , "./mpint.h" ":" "157"), err, "integer too large for the target type"); return 0; } static inline _Bool mpint_set_from_int64_t(mpint_t *t, int64_t val, _Bool uns, ajla_error_t __attribute__((__unused__)) *err){ if (sizeof(int64_t) <= sizeof(long)) { if (!uns) __gmpz_set_si(t, (long)val); else __gmpz_set_ui(t, (unsigned long)(uint64_t)val); } else { _Bool sign = val < 0 && !uns; if ((__builtin_expect((int)(sign), 0))) val = -(uint64_t)val; __gmpz_import(t, 1, 1, sizeof(int64_t), 0, 0, &val); if ((__builtin_expect((int)(sign), 0))) __gmpz_neg(t, t); } return 1; } static inline _Bool mpint_init_from_int64_t(mpint_t *t, int64_t val, ajla_error_t *err){ if (sizeof(int64_t) <= sizeof(long)) { __gmpz_init_set_si(t, (long)val); } else { if ((__builtin_expect((int)(!mpint_alloc_mayfail(t, sizeof(int64_t) * 8, err)), 0))) return 0; if ((__builtin_expect((int)(!mpint_set_from_int64_t(t, val, 0, err)), 0))) { __gmpz_clear(t); return 0; } } return 1; } static inline __attribute__((__always_inline__)) _Bool mpint_export_to_int64_t(const mpint_t *t, int64_t *result, ajla_error_t *err){ if (__gmpz_fits_slong_p(t)) { long l; l = __gmpz_get_si(t); if ((__builtin_expect((int)(l != (int64_t)l), 0))) goto doesnt_fit; *result = (int64_t)l; return 1; } else if (sizeof(int64_t) > sizeof(long)) { uint64_t ui; size_t bit = __gmpz_sizeinbase(t, 2); if (bit > 8 * sizeof(int64_t)) goto doesnt_fit; (void)__gmpz_export(&ui, ((void*)0), 1, sizeof(uint64_t), 0, 0, t); if (((t)->_mp_size < 0 ? -1 : (t)->_mp_size > 0) >= 0) { if ((int64_t)ui < 0) goto doesnt_fit; } else { ui = -ui; if ((int64_t)ui >= 0) goto doesnt_fit; } *result = (int64_t)ui; return 1; } doesnt_fit: fatal_mayfail(error_ajla_aux_(1, 5, 0 , "./mpint.h" ":" "157"), err, "integer too large for the target type"); return 0; } static inline __attribute__((__always_inline__)) _Bool mpint_export_to_uint64_t(const mpint_t *t, uint64_t *result, ajla_error_t *err){ if (__gmpz_fits_ulong_p(t)) { unsigned long l; l = __gmpz_get_ui(t); if ((__builtin_expect((int)(l != (uint64_t)l), 0))) goto doesnt_fit; *result = (uint64_t)l; return 1; } else if (sizeof(uint64_t) > sizeof(unsigned long)) { size_t bit; if ((__builtin_expect((int)(((t)->_mp_size < 0 ? -1 : (t)->_mp_size > 0) < 0), 0))) goto doesnt_fit; bit = __gmpz_sizeinbase(t, 2); if (bit > 8 * sizeof(uint64_t)) goto doesnt_fit; (void)__gmpz_export(result, ((void*)0), 1, sizeof(uint64_t), 0, 0, t); return 1; } doesnt_fit: fatal_mayfail(error_ajla_aux_(1, 5, 0 , "./mpint.h" ":" "157"), err, "integer too large for the target type"); return 0; } static inline _Bool mpint_set_from_int128_t(mpint_t *t, int128_t val, _Bool uns, ajla_error_t __attribute__((__unused__)) *err){ if (sizeof(int128_t) <= sizeof(long)) { if (!uns) __gmpz_set_si(t, (long)val); else __gmpz_set_ui(t, (unsigned long)(uint128_t)val); } else { _Bool sign = val < 0 && !uns; if ((__builtin_expect((int)(sign), 0))) val = -(uint128_t)val; __gmpz_import(t, 1, 1, sizeof(int128_t), 0, 0, &val); if ((__builtin_expect((int)(sign), 0))) __gmpz_neg(t, t); } return 1; } static inline _Bool mpint_init_from_int128_t(mpint_t *t, int128_t val, ajla_error_t *err){ if (sizeof(int128_t) <= sizeof(long)) { __gmpz_init_set_si(t, (long)val); } else { if ((__builtin_expect((int)(!mpint_alloc_mayfail(t, sizeof(int128_t) * 8, err)), 0))) return 0; if ((__builtin_expect((int)(!mpint_set_from_int128_t(t, val, 0, err)), 0))) { __gmpz_clear(t); return 0; } } return 1; } static inline __attribute__((__always_inline__)) _Bool mpint_export_to_int128_t(const mpint_t *t, int128_t *result, ajla_error_t *err){ if (__gmpz_fits_slong_p(t)) { long l; l = __gmpz_get_si(t); if ((__builtin_expect((int)(l != (int128_t)l), 0))) goto doesnt_fit; *result = (int128_t)l; return 1; } else if (sizeof(int128_t) > sizeof(long)) { uint128_t ui; size_t bit = __gmpz_sizeinbase(t, 2); if (bit > 8 * sizeof(int128_t)) goto doesnt_fit; (void)__gmpz_export(&ui, ((void*)0), 1, sizeof(uint128_t), 0, 0, t); if (((t)->_mp_size < 0 ? -1 : (t)->_mp_size > 0) >= 0) { if ((int128_t)ui < 0) goto doesnt_fit; } else { ui = -ui; if ((int128_t)ui >= 0) goto doesnt_fit; } *result = (int128_t)ui; return 1; } doesnt_fit: fatal_mayfail(error_ajla_aux_(1, 5, 0 , "./mpint.h" ":" "157"), err, "integer too large for the target type"); return 0; } static inline __attribute__((__always_inline__)) _Bool mpint_export_to_uint128_t(const mpint_t *t, uint128_t *result, ajla_error_t *err){ if (__gmpz_fits_ulong_p(t)) { unsigned long l; l = __gmpz_get_ui(t); if ((__builtin_expect((int)(l != (uint128_t)l), 0))) goto doesnt_fit; *result = (uint128_t)l; return 1; } else if (sizeof(uint128_t) > sizeof(unsigned long)) { size_t bit; if ((__builtin_expect((int)(((t)->_mp_size < 0 ? -1 : (t)->_mp_size > 0) < 0), 0))) goto doesnt_fit; bit = __gmpz_sizeinbase(t, 2); if (bit > 8 * sizeof(uint128_t)) goto doesnt_fit; (void)__gmpz_export(result, ((void*)0), 1, sizeof(uint128_t), 0, 0, t); return 1; } doesnt_fit: fatal_mayfail(error_ajla_aux_(1, 5, 0 , "./mpint.h" ":" "157"), err, "integer too large for the target type"); return 0; }



static inline _Bool mpint_import_from_code(mpint_t *m, const code_t *code, ip_t n_words, ajla_error_t *err)
{
 if ((__builtin_expect((int)(n_words >= size_t_limit + ((unsigned)(zero_()))), 0))) {
  fatal_mayfail(error_ajla_aux_(1, 4, 0 , "./mpint.h" ":" "164"), err, "integer too large");
  return 0;
 }
 if ((__builtin_expect((int)(n_words != 0), 1)) && (__builtin_expect((int)((code[!0 ? n_words - 1 : 0] & ((code_t)(-((code_t)1 << (8 * sizeof(code_t) - 2)) * 2))) != 0), 0))) {
  size_t i;
  code_t *copy = ((__builtin_expect((int)(!mem_check_overflow(0, n_words, sizeof(code_t), err)), 0)) ? ((code_t *)(void *)(((void*)0))) : ((code_t *)(void *)(mem_alloc_position((((size_t)(0) + (size_t)(n_words) * (size_t)(sizeof(code_t))) >= ((size_t)(0)) + (zero_()) ? ((size_t)(0) + (size_t)(n_words) * (size_t)(sizeof(code_t))) : ((size_t)(0))), err , "./mpint.h" ":" "169"))));
  if ((__builtin_expect((int)(!copy), 0)))
   return 0;
  for (i = 0; i < n_words; i++)
   copy[i] = ~code[i];
  __gmpz_import(m, n_words, !0 ? -1 : 1, sizeof(code_t), 0, 0, copy);
  mem_free_position(copy , "./mpint.h" ":" "175");
  __gmpz_com(m, m);
 } else {
  __gmpz_import(m, n_words, !0 ? -1 : 1, sizeof(code_t), 0, 0, code);
 }
 return 1;
}
# 219 "./mpint.h"
_Bool mpint_add(const mpint_t *s1, const mpint_t *s2, mpint_t *r, ajla_error_t *err);
_Bool mpint_subtract(const mpint_t *s1, const mpint_t *s2, mpint_t *r, ajla_error_t *err);
_Bool mpint_multiply(const mpint_t *s1, const mpint_t *s2, mpint_t *r, ajla_error_t *err);
_Bool mpint_divide(const mpint_t *s1, const mpint_t *s2, mpint_t *r, ajla_error_t *err);
_Bool mpint_modulo(const mpint_t *s1, const mpint_t *s2, mpint_t *r, ajla_error_t *err);
_Bool mpint_power(const mpint_t *s1, const mpint_t *s2, mpint_t *r, ajla_error_t *err);
_Bool mpint_and(const mpint_t *s1, const mpint_t *s2, mpint_t *r, ajla_error_t *err);
_Bool mpint_or(const mpint_t *s1, const mpint_t *s2, mpint_t *r, ajla_error_t *err);
_Bool mpint_xor(const mpint_t *s1, const mpint_t *s2, mpint_t *r, ajla_error_t *err);
_Bool mpint_shl(const mpint_t *s1, const mpint_t *s2, mpint_t *r, ajla_error_t *err);
_Bool mpint_shr(const mpint_t *s1, const mpint_t *s2, mpint_t *r, ajla_error_t *err);
_Bool mpint_bts(const mpint_t *s1, const mpint_t *s2, mpint_t *r, ajla_error_t *err);
_Bool mpint_btr(const mpint_t *s1, const mpint_t *s2, mpint_t *r, ajla_error_t *err);
_Bool mpint_btc(const mpint_t *s1, const mpint_t *s2, mpint_t *r, ajla_error_t *err);

_Bool mpint_equal(const mpint_t *s1, const mpint_t *s2, ajla_flat_option_t *r, ajla_error_t *err);
_Bool mpint_not_equal(const mpint_t *s1, const mpint_t *s2, ajla_flat_option_t *r, ajla_error_t *err);
_Bool mpint_less(const mpint_t *s1, const mpint_t *s2, ajla_flat_option_t *r, ajla_error_t *err);
_Bool mpint_less_equal(const mpint_t *s1, const mpint_t *s2, ajla_flat_option_t *r, ajla_error_t *err);
_Bool mpint_bt(const mpint_t *s1, const mpint_t *s2, ajla_flat_option_t *r, ajla_error_t *err);

_Bool mpint_not(const mpint_t *s, mpint_t *r, ajla_error_t *err);
_Bool mpint_neg(const mpint_t *s, mpint_t *r, ajla_error_t *err);
_Bool mpint_inc(const mpint_t *s, mpint_t *r, ajla_error_t *err);
_Bool mpint_dec(const mpint_t *s, mpint_t *r, ajla_error_t *err);
_Bool mpint_bsf(const mpint_t *s, mpint_t *r, ajla_error_t *err);
_Bool mpint_bsr(const mpint_t *s, mpint_t *r, ajla_error_t *err);
_Bool mpint_popcnt(const mpint_t *s, mpint_t *r, ajla_error_t *err);
# 255 "./mpint.h"
 _Bool mpint_init_from_real16_t(mpint_t *t, real16_t *valp, ajla_error_t *err);void mpint_export_to_real16_t(const mpint_t *t, real16_t *result); _Bool mpint_init_from_real32_t(mpint_t *t, real32_t *valp, ajla_error_t *err);void mpint_export_to_real32_t(const mpint_t *t, real32_t *result); _Bool mpint_init_from_real64_t(mpint_t *t, real64_t *valp, ajla_error_t *err);void mpint_export_to_real64_t(const mpint_t *t, real64_t *result); _Bool mpint_init_from_real80_t(mpint_t *t, real80_t *valp, ajla_error_t *err);void mpint_export_to_real80_t(const mpint_t *t, real80_t *result);


_Bool mpint_export_to_blob(const mpint_t *s, uint8_t **blob, size_t *blob_size, ajla_error_t *err);

static inline void str_add_mpint(char **s, size_t *l, const mpint_t *mp, uint16_t base_n)
{
 mpint_t mod, base, num;
 int8_t digit;
 int16_t base_m = (int16_t)base_n;
 ajla_flat_option_t neg, bo;
 size_t pos, i;

 pos = *l;

 mpint_init_from_int8_t(&mod, 0, ((void*)0));
 mpint_init_from_int16_t(&base, base_m, ((void*)0));
 mpint_alloc_mayfail(&num, 0, ((void*)0));
 mpint_add(mp, &mod, &num, ((void*)0));
 mpint_less(&num, &mod, &neg, ((void*)0));
 if (neg) {
  mpint_neg(&num, &num, ((void*)0));
 }

 do {
  mpint_modulo(&num, &base, &mod, ((void*)0));
  digit = 0;
  mpint_export_to_int8_t(&mod, &digit, ((void*)0));
  str_add_char(s, l, digit <= 9 ? '0' + (char)digit : 'a' - 10 + (char)digit);
  mpint_less(&num, &base, &bo, ((void*)0));
  if (!bo) mpint_divide(&num, &base, &num, ((void*)0));
 } while (!bo);

 if (neg)
  str_add_char(s, l, '-');

 mpint_free(&mod);
 mpint_free(&base);
 mpint_free(&num);

 for (i = 0; i < (*l - pos) / 2; i++) {
  char c = (*s)[pos + i];
  (*s)[pos + i] = (*s)[*l - 1 - i];
  (*s)[*l - 1 - i] = c;
 }
}


void mpint_init(void);
void mpint_done(void);
# 29 "./data.h" 2

# 1 "./tree.h" 1
# 22 "./tree.h"
struct tree_entry {
 struct tree_entry *children[2];
 struct tree_entry **parent;
 uchar_efficient_t color;
 uchar_efficient_t idx;
};
# 36 "./tree.h"
struct tree {
 struct tree_entry *root;
};

static inline void tree_init(struct tree *root)
{
 root->root = ((void*)0);
}

static inline _Bool tree_is_empty(struct tree *root)
{
 return !root->root;
}







struct tree_insert_position {
 size_t idx;
 struct tree_entry **link;
};

static inline struct tree_entry *tree_find_for_insert(
 struct tree *root,
 int (*compare)(const struct tree_entry *, uintptr_t),
 uintptr_t key,
 struct tree_insert_position *pos)
{
 struct tree_entry *p = root->root;
 if (pos) {
  pos->idx = 2;
  pos->link = &root->root;
 }
 while (p) {
  int c;
  size_t cc;
  ((void)0);
  c = compare(p, key);
  if (!c)
   return p;
  cc = c < 0;

  if (pos) {
   pos->idx = cc;
   pos->link = &p->children[cc];
  }
  p = p->children[cc];
 }
 return ((void*)0);
}

static inline struct tree_entry *tree_find(
 struct tree *root,
 int (*compare)(const struct tree_entry *, uintptr_t),
 uintptr_t key)
{
 return tree_find_for_insert(root, compare, key, ((void*)0));
}

static inline struct tree_entry *tree_find_next(
 struct tree *root,
 int (*compare)(const struct tree_entry *, uintptr_t),
 uintptr_t key)
{
 struct tree_entry *p = root->root;
 struct tree_entry *last_candidate = ((void*)0);
 while (p) {
  int c;
  size_t cc;
  ((void)0);
  c = compare(p, key);
  if (c > 0)
   last_candidate = p;
  cc = c <= 0;
  p = p->children[cc];
 }
 return last_candidate;
}

static inline struct tree_entry *tree_find_best(
 struct tree *root,
 int (*compare)(const struct tree_entry *, uintptr_t),
 uintptr_t key)
{
 struct tree_entry *p = root->root;
 struct tree_entry *last_candidate = ((void*)0);
 while (p) {
  int c;
  size_t cc;
  ((void)0);
  c = compare(p, key);
  if (c >= 0)
   last_candidate = p;
  if (!c)
   break;
  cc = c < 0;
  p = p->children[cc];
 }
 return last_candidate;
}

void tree_insert_after_find_impl(struct tree_entry *, uchar_efficient_t idx, struct tree_entry **link);

static inline void tree_insert_after_find(struct tree_entry *p, const struct tree_insert_position *pos)
{
 tree_insert_after_find_impl(p, (uchar_efficient_t)pos->idx, pos->link);
}

void tree_delete(struct tree_entry *);

struct tree_entry * tree_first(struct tree *);
struct tree_entry * tree_next(struct tree_entry *);
struct tree_entry * tree_last(struct tree *);

static inline struct tree_entry *tree_any(struct tree *root)
{
 return root->root;
}
# 31 "./data.h" 2

# 1 "./tick.h" 1
# 43 "./tick.h"
extern uint32_t tick_us;
extern uint32_t thread_tick;

typedef unsigned tick_stamp_t;
extern _Atomic tick_stamp_t *tick_stamp_ptr;



void tick_suspend(void);
void tick_resume(void);

void tick_init(void);
void tick_done(void);
# 33 "./data.h" 2
# 1 "./profile.h" 1
# 24 "./profile.h"
extern uchar_efficient_t profiling;
extern uchar_efficient_t profiling_escapes;

typedef uint64_t profile_counter_t;

void profile_unblock(void);
profile_counter_t profile_sample(void);
void profile_collect(const char *function_name, profile_counter_t profiling_counter, profile_counter_t call_counter);
void profile_escape_collect(const char *function_name, profile_counter_t profiling_counter, unsigned line, code_t code, unsigned short compile_line);

_Bool function_enable_profile(const char *option, size_t l);

void profile_init(void);
void profile_done(void);
# 34 "./data.h" 2
# 104 "./data.h"
struct data;
struct thunk;
struct execution_control;
# 308 "./data.h"
typedef void *pointer_t;



static inline __attribute__((__always_inline__)) pointer_t pointer_thunk(struct thunk *thunk)
{
 return POINTER_TAG_ADD(thunk);
}

static inline __attribute__((__always_inline__)) pointer_t pointer_data(const struct data *data)
{
 return (pointer_t)data;
}

static inline __attribute__((__always_inline__)) _Bool pointer_is_thunk(const pointer_t ptr)
{
 return POINTER_TAG_GET(ptr) != 0;
}

static inline __attribute__((__always_inline__)) void *pointer_get_value_(const pointer_t ptr)
{
 return ptr;
}

static inline __attribute__((__always_inline__)) void *pointer_get_value_strip_tag_(const pointer_t ptr)
{
 return POINTER_TAG_CLEAR(ptr);
}

static inline __attribute__((__always_inline__)) void *pointer_get_value_sub_tag_(const pointer_t ptr)
{
 return POINTER_TAG_SUB(ptr);
}
# 404 "./data.h"
static inline __attribute__((__always_inline__)) _Bool pointer_is_equal(pointer_t ptr1, pointer_t ptr2)
{
 _Bool ret;

 ret = ptr1 == ptr2;



 return ret;
}

static inline __attribute__((__always_inline__)) pointer_t pointer_empty(void)
{



 return pointer_data(((void*)0));

}

static inline __attribute__((__always_inline__)) _Bool pointer_is_empty(pointer_t ptr)
{
 return pointer_is_equal(ptr, pointer_empty());
}

static inline __attribute__((__always_inline__)) pointer_t pointer_mark(void)
{





 return pointer_thunk(((void*)0));

}

static inline __attribute__((__always_inline__)) _Bool pointer_is_mark(pointer_t ptr)
{
 return pointer_is_equal(ptr, pointer_mark());
}

static inline __attribute__((__always_inline__)) void pointer_poison(pointer_t __attribute__((__unused__)) *ptr)
{



}



static inline __attribute__((__always_inline__)) struct thunk *pointer_get_thunk_(pointer_t ptr , const char __attribute__((__unused__)) *position_arg)
{
 ((void)(zero_()));
 return (struct thunk *)pointer_get_value_sub_tag_(ptr);
}

static inline __attribute__((__always_inline__)) struct data *pointer_get_data_(pointer_t ptr , const char __attribute__((__unused__)) *position_arg)
{
 ((void)(zero_()));
 return (struct data *)pointer_get_value_(ptr);
}
# 497 "./data.h"
static inline void *ptrcomp_verify(void *ptr)
{
 do { if ((__builtin_expect((int)((ptr_to_num(ptr) & ((uintptr_t)1 << 0)) != 0), 0))) { if (1) fatal("the allocator returned pointer %p that is not compatible with tag %""l" "u""", (ptr), (uintmax_t)((uintptr_t)1 << 0)); else ((void)(zero_())); } } while (0);
 return ptr;
}






static inline _Bool data_element_is_const(const unsigned char *flat, size_t size)
{
 size_t i;
 for (i = 0; i < size; i++)
  if (flat[i] != flat[0])
   return 0;
 return 1;
}






typedef struct frame_s_ frame_s;
struct frame_struct;
# 690 "./data.h"
static inline __attribute__((__always_inline__)) void frame_set_flag(frame_s *fp, frame_t idx)
{
 ((void)(zero_()));
 (((unsigned char *)(void *)(fp)))[idx] = 1;
}
static inline __attribute__((__always_inline__)) void frame_clear_flag(frame_s *fp, frame_t idx)
{
 ((void)(zero_()));
 (((unsigned char *)(void *)(fp)))[idx] = 0;
}
static inline __attribute__((__always_inline__)) _Bool frame_test_flag(frame_s *fp, frame_t idx)
{





 unsigned char val = (((unsigned char *)(void *)(fp)))[idx];
 ((void)(zero_()));
 return val;

}
static inline __attribute__((__always_inline__)) _Bool frame_test_and_set_flag(frame_s *fp, frame_t idx)
{
 unsigned char val = (((unsigned char *)(void *)(fp)))[idx];
 ((void)(zero_()));
 if (val) return 1;
 (((unsigned char *)(void *)(fp)))[idx] = 1;
 return 0;
}
static inline __attribute__((__always_inline__)) _Bool frame_test_and_clear_flag(frame_s *fp, frame_t idx)
{
 unsigned char val = (((unsigned char *)(void *)(fp)))[idx];
 ((void)(zero_()));
 if (!val) return 0;
 (((unsigned char *)(void *)(fp)))[idx] = 0;
 return 1;
}
# 750 "./data.h"
static inline void memcpy_slots(unsigned char *dest, const unsigned char *src, frame_t n_slots)
{
 src = (((void)(zero_())), ((void)(zero_())), (src));
 dest = (((void)(zero_())), ((void)(zero_())), (dest));
 memcpy_fast(dest, src, n_slots * ((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))));
}
# 764 "./data.h"
struct data_flat {
 type_tag_t data_type;
 unsigned char flexible_array[0];
};

struct data_longint {
 mpint_t mp;
};

struct data_record {
 const struct type *definition;
 char flexible_array[0];
};

struct data_option {
 ajla_option_t option;
 pointer_t pointer;
};

struct data_array_flat {
 int64_t n_used_entries;
 int64_t n_allocated_entries;
 const struct type *type;
 unsigned char flexible_array[0];
};

struct data_array_slice {
 int64_t n_entries;
 pointer_t reference;
 const struct type *type;
 unsigned char *flat_data_minus_data_array_offset;
};

struct data_array_pointers {
 int64_t n_used_entries;
 int64_t n_allocated_entries;
 pointer_t *pointer;
 pointer_t pointer_array[0];
};
# 821 "./data.h"
typedef uint64_t array_index_t;


typedef uchar_efficient_t btree_entries_t;

struct data_array_same {
 array_index_t n_entries;
 pointer_t pointer;
};

struct btree_level {
 array_index_t end_index;
 pointer_t node;
};

struct data_array_btree {
 btree_entries_t n_used_btree_entries;
 btree_entries_t n_allocated_btree_entries;
 uchar_efficient_t depth;
 struct btree_level btree[0];
};

struct data_array_incomplete {
 pointer_t first;
 pointer_t next;
};

struct function_argument {
 type_tag_t tag;
 union {
  pointer_t ptr;
  unsigned char slot[((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))];
 } u;
};

struct data_function_reference {
 union {
  pointer_t indirect;
  pointer_t *direct;
 } u;
 uchar_efficient_t is_indirect;
 arg_t n_curried_arguments;




 struct function_argument arguments[0];
};

struct data_resource {
 void (*close)(struct data *);




 char flexible_array[0];
};




struct local_variable {
 const struct type *type;
};

struct local_variable_flags {
 _Bool may_be_borrowed;
};

struct local_arg {
 frame_t slot;
 char may_be_borrowed;
 char may_be_flat;
};

struct line_position {
 ip_t ip;
 unsigned line;
};

struct cache_entry;

struct cache_entry_return {
 struct cache_entry *ce;
 pointer_t ptr;
 struct execution_control *ex;
};

struct cache_entry {
 struct tree_entry entry;
 arg_t n_pending;
 _Bool save;
 struct list wait_list;
 struct cache_entry_return *returns;
 pointer_t arguments[];
};

struct escape_data {
 _Atomic profile_counter_t counter;
 _Atomic unsigned short line;
};

struct module_designator;

struct data_function {
 frame_t frame_slots;
 frame_t n_bitmap_slots;
 arg_t n_arguments;
 arg_t n_return_values;
 code_t *code;
 ip_t code_size;
 const struct local_variable *local_variables;
 const struct local_variable_flags *local_variables_flags;
 frame_t n_slots;
 const struct local_arg *args;
 pointer_t types_ptr;
 const struct type *record_definition;
 const struct module_designator *module_designator;
 const struct function_designator *function_designator;
 char *function_name;
 struct line_position *lp;
 size_t lp_size;

 pointer_t codegen;
 _Atomic uchar_efficient_t codegen_failed;

 struct data *loaded_cache;
 struct tree cache;
 _Atomic profile_counter_t profiling_counter;
 _Atomic profile_counter_t call_counter;
 struct escape_data *escape_data;
 _Bool leaf;
 _Bool is_saved;
 frame_t local_directory_size;
 pointer_t *local_directory[0];
};

struct data_function_types {
 size_t n_types;
 const struct type *types[0];
};





typedef struct {
 void *fp;



 ip_t ip;

} code_return_t;

struct cg_upcall_vector_s;

struct trap_record {
 size_t source_ip;
 size_t destination_ip;
};

struct data_codegen {





 void *unoptimized_code_base;
 size_t unoptimized_code_size;
 struct data *function;
 _Bool is_saved;
 frame_t n_entries;
 size_t *offsets;
 char *unoptimized_code[0];
};


union internal_arg {
 void *ptr;
 size_t i;
};

struct data_internal {
 void *(*fn)(frame_s *fp, const code_t *ip, union internal_arg *);
 union internal_arg arguments[0];
};

struct data_saved {
 size_t total_size;
 size_t n_offsets;
 size_t offsets[0];
};

struct data_saved_cache {
 size_t n_entries;
 arg_t n_arguments;
 arg_t n_return_values;
 pointer_t pointers[0];
};

typedef uchar_efficient_t tag_t;
# 1063 "./data.h"
struct data {
 refcount_t refcount_;



 union {
  struct data_flat flat;
  struct data_longint longint;
  struct data_record record;
  struct data_option option;
  struct data_array_flat array_flat;
  struct data_array_slice array_slice;
  struct data_array_pointers array_pointers;
  struct data_array_same array_same;
  struct data_array_btree array_btree;
  struct data_array_incomplete array_incomplete;
  struct data_function_reference function_reference;
  struct data_resource resource;


  struct data_function function;
  struct data_function_types function_types;

  struct data_codegen codegen;

  struct data_internal internal;


  struct data_saved saved;
  struct data_saved_cache saved_cache;
 } u_;
};
# 1125 "./data.h"
static inline __attribute__((__always_inline__)) unsigned char *da_flat(struct data *d)
{
 (((void)(zero_())));
 return ((unsigned char *)(void *)(d)) + ((((__builtin_offsetof(struct data, u_.flat.flexible_array)) + ((( (__alignof__(int8_t) - 1) | (__alignof__(int16_t) - 1) | (__alignof__(int32_t) - 1) | (__alignof__(int64_t) - 1) | (__alignof__(int128_t) - 1) | (__alignof__(int8_t) - 1) | (__alignof__(int16_t) - 1) | (__alignof__(int32_t) - 1) | (__alignof__(int64_t) - 1) | (__alignof__(int128_t) - 1) | (__alignof__(real16_t) - 1) | (__alignof__(real32_t) - 1) | (__alignof__(real64_t) - 1) | (__alignof__(real80_t) - 1) | (__alignof__(max_align_t) - 1) | (__alignof__(ajla_flat_option_t) - 1) | (__alignof__(void *) - 1) | 1) + 1)) - 1) & ~(((( (__alignof__(int8_t) - 1) | (__alignof__(int16_t) - 1) | (__alignof__(int32_t) - 1) | (__alignof__(int64_t) - 1) | (__alignof__(int128_t) - 1) | (__alignof__(int8_t) - 1) | (__alignof__(int16_t) - 1) | (__alignof__(int32_t) - 1) | (__alignof__(int64_t) - 1) | (__alignof__(int128_t) - 1) | (__alignof__(real16_t) - 1) | (__alignof__(real32_t) - 1) | (__alignof__(real64_t) - 1) | (__alignof__(real80_t) - 1) | (__alignof__(max_align_t) - 1) | (__alignof__(ajla_flat_option_t) - 1) | (__alignof__(void *) - 1) | 1) + 1)) - 1 + 0 * (__builtin_offsetof(struct data, u_.flat.flexible_array)))));
}
static inline __attribute__((__always_inline__)) frame_s *da_record_frame(struct data *d)
{
 (((void)(zero_())));
 return ((frame_s *)(void *)(((const char *)(void *)(d)) + ((((__builtin_offsetof(struct data, u_.record.flexible_array)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct data, u_.record.flexible_array)))))));
}
static inline __attribute__((__always_inline__)) unsigned char *da_array_flat(struct data *d)
{
 (((void)(zero_())));
 return ((unsigned char *)(void *)(d)) + ((((__builtin_offsetof(struct data, u_.array_flat.flexible_array)) + ((( (__alignof__(int8_t) - 1) | (__alignof__(int16_t) - 1) | (__alignof__(int32_t) - 1) | (__alignof__(int64_t) - 1) | (__alignof__(int128_t) - 1) | (__alignof__(int8_t) - 1) | (__alignof__(int16_t) - 1) | (__alignof__(int32_t) - 1) | (__alignof__(int64_t) - 1) | (__alignof__(int128_t) - 1) | (__alignof__(real16_t) - 1) | (__alignof__(real32_t) - 1) | (__alignof__(real64_t) - 1) | (__alignof__(real80_t) - 1) | (__alignof__(max_align_t) - 1) | (__alignof__(ajla_flat_option_t) - 1) | (__alignof__(void *) - 1) | 1) + 1)) - 1) & ~(((( (__alignof__(int8_t) - 1) | (__alignof__(int16_t) - 1) | (__alignof__(int32_t) - 1) | (__alignof__(int64_t) - 1) | (__alignof__(int128_t) - 1) | (__alignof__(int8_t) - 1) | (__alignof__(int16_t) - 1) | (__alignof__(int32_t) - 1) | (__alignof__(int64_t) - 1) | (__alignof__(int128_t) - 1) | (__alignof__(real16_t) - 1) | (__alignof__(real32_t) - 1) | (__alignof__(real64_t) - 1) | (__alignof__(real80_t) - 1) | (__alignof__(max_align_t) - 1) | (__alignof__(ajla_flat_option_t) - 1) | (__alignof__(void *) - 1) | 1) + 1)) - 1 + 0 * (__builtin_offsetof(struct data, u_.array_flat.flexible_array)))));
}
# 1148 "./data.h"
static inline __attribute__((__always_inline__)) const struct type *da_type(struct data *fn, size_t idx)
{
 struct data *t = pointer_get_data_(((((void)(zero_()))), &(fn)->u_.function)->types_ptr , "./data.h" ":" "1150");
 ((void)(zero_()));
 return ((((void)(zero_()))), &(t)->u_.function_types)->types[idx];
}




static inline void *da_resource(struct data *d)
{
 (((void)(zero_())));
 return ((void *)(void *)(((const char *)(void *)(d)) + ((((__builtin_offsetof(struct data, u_.resource.flexible_array)) + ((( (__alignof__(int8_t) - 1) | (__alignof__(int16_t) - 1) | (__alignof__(int32_t) - 1) | (__alignof__(int64_t) - 1) | (__alignof__(int128_t) - 1) | (__alignof__(int8_t) - 1) | (__alignof__(int16_t) - 1) | (__alignof__(int32_t) - 1) | (__alignof__(int64_t) - 1) | (__alignof__(int128_t) - 1) | (__alignof__(real16_t) - 1) | (__alignof__(real32_t) - 1) | (__alignof__(real64_t) - 1) | (__alignof__(real80_t) - 1) | (__alignof__(max_align_t) - 1) | (__alignof__(ajla_flat_option_t) - 1) | (__alignof__(void *) - 1) | 1) + 1)) - 1) & ~(((( (__alignof__(int8_t) - 1) | (__alignof__(int16_t) - 1) | (__alignof__(int32_t) - 1) | (__alignof__(int64_t) - 1) | (__alignof__(int128_t) - 1) | (__alignof__(int8_t) - 1) | (__alignof__(int16_t) - 1) | (__alignof__(int32_t) - 1) | (__alignof__(int64_t) - 1) | (__alignof__(int128_t) - 1) | (__alignof__(real16_t) - 1) | (__alignof__(real32_t) - 1) | (__alignof__(real64_t) - 1) | (__alignof__(real80_t) - 1) | (__alignof__(max_align_t) - 1) | (__alignof__(ajla_flat_option_t) - 1) | (__alignof__(void *) - 1) | 1) + 1)) - 1 + 0 * (__builtin_offsetof(struct data, u_.resource.flexible_array)))))));
}


static inline __attribute__((__always_inline__)) struct data *data_init_(struct data *d, tag_t tag)
{
 if ((__builtin_expect((int)(!d), 0)))
  return ((void*)0);




 refcount_init_tag_(&d->refcount_, tag, "./data.h" ":" "1173");




 return d;
}

static inline __attribute__((__always_inline__)) void *data_pointer_tag(void *d, tag_t __attribute__((__unused__)) tag)
{



 return d;
}






static inline void *data_untag_(void *d, const char __attribute__((__unused__)) *fl)
{
# 1205 "./data.h"
 return d;

}
# 1217 "./data.h"
struct stack_trace_entry {
 const struct module_designator *module_designator;
 const char *function_name;
 unsigned line;
};

struct stack_trace {
 struct stack_trace_entry *trace;
 size_t trace_n;
};

struct thunk_exception {
 ajla_error_t err;
 char *msg;
 struct stack_trace tr;
};

struct thunk_result {
 pointer_t ptr;
 _Bool wanted;
};

struct thunk {
 refcount_t refcount_;



 union {





  struct {
   union {

    pointer_t function_reference;



    struct execution_control *execution_control;
   } u;
   struct thunk_result results[1];
  } function_call;

  struct {
   struct thunk *thunk;
   arg_t idx;
  } multi_ret_reference;

  struct thunk_exception exception;
 } u;
};

static inline tag_t thunk_tag_(struct thunk *t, const char __attribute__((__unused__)) *position)
{
 tag_t tag;



 tag = refcount_tag_get(&t->refcount_);

 ((void)(zero_()));
 return tag;
}


static inline tag_t thunk_tag_volatile_(struct thunk *t, const char __attribute__((__unused__)) *position)
{
 tag_t tag;



 tag = refcount_tag_get(&t->refcount_);

 ((void)(zero_()));
 return tag;
}


static inline void thunk_tag_set_(struct thunk *t, tag_t __attribute__((__unused__)) old_tag, tag_t new_tag, const char __attribute__((__unused__)) *position)
{




 refcount_tag_set_(&t->refcount_, old_tag, new_tag, position);

}


static inline tag_t da_thunk_tag_(void *dt, const char __attribute__((__unused__)) *position)
{
 tag_t tag;




 ((void)(zero_()));
 tag = refcount_tag_get(((refcount_t *)(void *)(((char *)(void *)(dt)) + __builtin_offsetof(struct data, refcount_))));

 ((void)(zero_()));
 return tag;
}




static inline refcount_t *da_thunk_refcount_(void *dt, const char __attribute__((__unused__)) *position)
{
 ((void)(zero_()));
 return ((refcount_t *)(void *)(((char *)(void *)(dt)) + __builtin_offsetof(struct data, refcount_)));
}






static inline _Bool thunk_is_finished(struct thunk *t)
{
 tag_t tag = thunk_tag_volatile_(t, "./data.h" ":" "1338");
 return tag == 23 ||
  (tag == 24 && thunk_tag_volatile_(t->u.multi_ret_reference.thunk, "./data.h" ":" "1340") == 23);
}

static inline struct thunk *thunk_pointer_tag(struct thunk *t)
{



 return t;
}

static inline void *thunk_untag_(struct thunk *t, const char __attribute__((__unused__)) *fl)
{




 return t;

}
# 1374 "./data.h"
typedef unsigned timestamp_t;






struct frame_struct {
 struct data *function;
 ip_t previous_ip;
 timestamp_t timestamp;
 stack_size_t available_slots;
 uchar_efficient_t mode;




 char variables_[];
};

struct stack_bottom {
 struct execution_control *ex;
 stack_size_t useable_slots;
 pointer_t ret;
};
# 1418 "./data.h"
static inline const struct type *frame_get_type_of_local(const frame_s *fp, frame_t pos)
{
 const struct type *t;
 const struct data *function = (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function;
 t = ((((void)(zero_()))), &(function)->u_.function)->local_variables[pos].type;
 ((void)(zero_()));
 return t;
}

static inline ip_t frame_ip(const frame_s *fp, const code_t *ip)
{
 ((void)(zero_()));
 return (ip_t)(ip - ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code);
}

static inline frame_s * frame_up(frame_s *fp)
{
 char *next = ((char *)(void *)(fp)) + ((size_t)((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->frame_slots * ((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))));
 return ((frame_s *)(void *)(next));
}

static inline _Bool frame_is_top(frame_s *fp)
{
 return (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function == ((void*)0);
}

static inline struct stack_bottom *frame_stack_bottom(frame_s *fp)
{
 char *bottom = ((char *)(void *)((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_))))))))) - (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->available_slots * ((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))) - (((sizeof(struct stack_bottom)) + ((((( (__alignof__(int8_t) - 1) | (__alignof__(int16_t) - 1) | (__alignof__(int32_t) - 1) | (__alignof__(int64_t) - 1) | (__alignof__(int128_t) - 1) | (__alignof__(int8_t) - 1) | (__alignof__(int16_t) - 1) | (__alignof__(int32_t) - 1) | (__alignof__(int64_t) - 1) | (__alignof__(int128_t) - 1) | (__alignof__(real16_t) - 1) | (__alignof__(real32_t) - 1) | (__alignof__(real64_t) - 1) | (__alignof__(real80_t) - 1) | (__alignof__(max_align_t) - 1) | (__alignof__(ajla_flat_option_t) - 1) | (__alignof__(void *) - 1) | 1) + 1)) >= (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) ? ((( (__alignof__(int8_t) - 1) | (__alignof__(int16_t) - 1) | (__alignof__(int32_t) - 1) | (__alignof__(int64_t) - 1) | (__alignof__(int128_t) - 1) | (__alignof__(int8_t) - 1) | (__alignof__(int16_t) - 1) | (__alignof__(int32_t) - 1) | (__alignof__(int64_t) - 1) | (__alignof__(int128_t) - 1) | (__alignof__(real16_t) - 1) | (__alignof__(real32_t) - 1) | (__alignof__(real64_t) - 1) | (__alignof__(real80_t) - 1) | (__alignof__(max_align_t) - 1) | (__alignof__(ajla_flat_option_t) - 1) | (__alignof__(void *) - 1) | 1) + 1)) : (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))) - 1) & ~(((((( (__alignof__(int8_t) - 1) | (__alignof__(int16_t) - 1) | (__alignof__(int32_t) - 1) | (__alignof__(int64_t) - 1) | (__alignof__(int128_t) - 1) | (__alignof__(int8_t) - 1) | (__alignof__(int16_t) - 1) | (__alignof__(int32_t) - 1) | (__alignof__(int64_t) - 1) | (__alignof__(int128_t) - 1) | (__alignof__(real16_t) - 1) | (__alignof__(real32_t) - 1) | (__alignof__(real64_t) - 1) | (__alignof__(real80_t) - 1) | (__alignof__(max_align_t) - 1) | (__alignof__(ajla_flat_option_t) - 1) | (__alignof__(void *) - 1) | 1) + 1)) >= (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) ? ((( (__alignof__(int8_t) - 1) | (__alignof__(int16_t) - 1) | (__alignof__(int32_t) - 1) | (__alignof__(int64_t) - 1) | (__alignof__(int128_t) - 1) | (__alignof__(int8_t) - 1) | (__alignof__(int16_t) - 1) | (__alignof__(int32_t) - 1) | (__alignof__(int64_t) - 1) | (__alignof__(int128_t) - 1) | (__alignof__(real16_t) - 1) | (__alignof__(real32_t) - 1) | (__alignof__(real64_t) - 1) | (__alignof__(real80_t) - 1) | (__alignof__(max_align_t) - 1) | (__alignof__(ajla_flat_option_t) - 1) | (__alignof__(void *) - 1) | 1) + 1)) : (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))) - 1 + 0 * (sizeof(struct stack_bottom))));
 return ((struct stack_bottom *)(void *)(bottom));
}

static inline struct execution_control *frame_execution_control(frame_s *fp)
{
 return frame_stack_bottom(fp)->ex;
}

static inline void stack_free(struct stack_bottom *stack)
{
 mem_free_aligned_position(stack , "./data.h" ":" "1457");
}

static inline void frame_init(frame_s *fp, struct data *function, timestamp_t timestamp, uchar_efficient_t mode)
{
 ((void)(zero_()));
 ((void)(zero_()));
 if ((__builtin_expect((int)(profiling), 0))) {
  profile_counter_t call_counter = __c11_atomic_load(&((((void)(zero_()))), &(function)->u_.function)->call_counter, 0);
  call_counter++;
  __c11_atomic_store(&((((void)(zero_()))), &(function)->u_.function)->call_counter, call_counter, 0);
 }
 (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->timestamp = timestamp;
 (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->mode = mode;



 (void)memset(fp, 0, ((((void)(zero_()))), &(function)->u_.function)->n_bitmap_slots * ((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))));
}

frame_s * u_stack_alloc(struct execution_control *ex, struct data *function, ajla_error_t *mayfail);
frame_s * u_stack_expand(frame_s *fp, struct data *function, ajla_error_t *mayfail);
frame_s * u_stack_split(frame_s *from_fp, frame_s *to_fp, frame_s **high, ajla_error_t *mayfail);







void u_stack_trace_init(struct stack_trace *st);
void u_stack_trace_free(struct stack_trace *st);
_Bool u_stack_trace_get_location(struct data *function, ip_t ip_rel, struct stack_trace_entry *result);
void u_stack_trace_capture(struct stack_trace *st, frame_s *fp, const code_t *ip, unsigned max_depth);
char *u_stack_trace_string(struct stack_trace *st, ajla_error_t *err);
void u_stack_trace_print(struct stack_trace *st);






struct data * u_data_alloc_flat_mayfail(type_tag_t type, const unsigned char *flat, size_t size, ajla_error_t *mayfail , const char __attribute__((__unused__)) *position_arg);
struct data * u_data_alloc_longint_mayfail(unsigned long bits, ajla_error_t *mayfail , const char __attribute__((__unused__)) *position_arg);
struct data * u_data_alloc_option_mayfail(ajla_error_t *mayfail , const char __attribute__((__unused__)) *position_arg);
struct data * u_data_alloc_record_mayfail(const struct record_definition *def, ajla_error_t *mayfail , const char __attribute__((__unused__)) *position_arg);
struct data * u_data_alloc_array_flat_mayfail(const struct type *type, int64_t n_allocated, int64_t n_used, _Bool clear, ajla_error_t *mayfail , const char __attribute__((__unused__)) *position_arg);
struct data * u_data_alloc_array_slice_mayfail(struct data *base, unsigned char *data, int64_t start, int64_t len, ajla_error_t *mayfail , const char __attribute__((__unused__)) *position_arg);
struct data * u_data_alloc_array_pointers_mayfail(int64_t n_allocated, int64_t n_used, ajla_error_t *mayfail , const char __attribute__((__unused__)) *position_arg);
struct data * u_data_alloc_array_same_mayfail(array_index_t n_entries, ajla_error_t *mayfail , const char __attribute__((__unused__)) *position_arg);
struct data * u_data_alloc_array_incomplete(struct data *first, pointer_t next, ajla_error_t *mayfail , const char __attribute__((__unused__)) *position_arg);
struct data * u_data_alloc_function_reference_mayfail(arg_t n_curried_arguments, ajla_error_t *mayfail , const char __attribute__((__unused__)) *position_arg);
void u_data_fill_function_reference(struct data *function_reference, arg_t a, pointer_t ptr);
void u_data_fill_function_reference_flat(struct data *function_reference, arg_t a, const struct type *type, const unsigned char *data);
struct data * u_data_alloc_resource_mayfail(size_t size, void (*close)(struct data *), ajla_error_t *mayfail , const char __attribute__((__unused__)) *position_arg);

extern pointer_t *u_out_of_memory_ptr;
struct thunk * u_thunk_alloc_exception_error(ajla_error_t err, char *msg, frame_s *fp, const code_t *ip , const char __attribute__((__unused__)) *position_arg);
pointer_t u_pointer_error(ajla_error_t err, frame_s *fp, const code_t *ip , const char __attribute__((__unused__)) *position_arg);
char *u_thunk_exception_string(struct thunk *thunk, ajla_error_t *err);
char *u_thunk_exception_payload(struct thunk *thunk, ajla_error_t *err);
void u_thunk_exception_print(struct thunk *thunk);

_Bool u_thunk_alloc_function_call(pointer_t function_reference, arg_t n_return_values, struct thunk *result[], ajla_error_t *mayfail);
_Bool u_thunk_alloc_blackhole(struct execution_control *ex, arg_t n_return_values, struct thunk *result[], ajla_error_t *mayfail);
# 1543 "./data.h"
struct execution_control_wait {
 struct list wait_entry;
 mutex_t *mutex_to_lock;
 struct execution_control *execution_control;
};

struct execution_control {
 ip_t current_ip;
 frame_s *current_frame;
 struct stack_bottom *stack;

 struct thunk *thunk;
 struct list wait_list;

 void (*callback)(void *, pointer_t);
 void *callback_cookie;

 refcount_t wait_state;
 struct list waiting_list_entry;
 void *waiting_list_head;
 struct execution_control_wait wait[2];

 uint64_t atomic;
 _Bool atomic_interrupted;
};

_Bool u_are_there_dereferenced(void);
void u_execution_control_unlink_and_submit(struct execution_control *ex, _Bool can_allocate_memory);
_Bool u_execution_control_acquire(struct execution_control *ex);
void u_wake_up_wait_list(struct list *wait_list, mutex_t *mutex_to_lock, _Bool can_allocate_memory);
void *u_thunk_terminate(struct thunk *t, arg_t n_return_values);
struct execution_control *u_execution_control_alloc(ajla_error_t *mayfail);
void u_execution_control_free(struct execution_control *ex);
void u_execution_control_terminate(struct execution_control *ex, pointer_t ptr);






void u_free_cache_entry(struct data *d, struct cache_entry *ce);

static inline __attribute__((__always_inline__)) refcount_t *pointer_get_refcount_(pointer_t ptr)
{
 void *p = pointer_get_value_strip_tag_(ptr);
 return !pointer_is_thunk(ptr) ? &((struct data *)p)->refcount_ : &((struct thunk *)p)->refcount_;
}

void u_pointer_dereference_(pointer_t ptr , const char __attribute__((__unused__)) *position_arg);


static inline void data_dereference(struct data *data)
{
 u_pointer_dereference_(pointer_data(data) , "./data.h" ":" "1596");
}

static inline void pointer_reference_owned(pointer_t ptr)
{
 refcount_t *r = pointer_get_refcount_(ptr);
 if ((__builtin_expect((int)(!refcount_is_read_only(r)), 1)))
  refcount_add_raw_(r, 256, "./data.h" ":" "1603");
}

static inline void pointer_reference_owned_multiple(pointer_t ptr, refcount_int_t n)
{
 refcount_t *r = pointer_get_refcount_(ptr);
 if ((__builtin_expect((int)(!refcount_is_read_only(r)), 1)))
  refcount_add_raw_(r, (refcount_int_t)(n) * 256, "./data.h" ":" "1610");
}

static inline void data_reference(struct data *d)
{
 if ((__builtin_expect((int)(!refcount_is_read_only(&d->refcount_)), 1)))
  refcount_add_raw_(&d->refcount_, 256, "./data.h" ":" "1616");
}

static inline void thunk_reference(struct thunk *t)
{
 if ((__builtin_expect((int)(!refcount_is_read_only(&t->refcount_)), 1)))
  refcount_add_raw_(&t->refcount_, 256, "./data.h" ":" "1622");
}

static inline void thunk_reference_nonatomic(struct thunk *t)
{
 refcount_inc_nonatomic_(&t->refcount_, "./data.h" ":" "1627");
}

static inline _Bool thunk_dereference_nonatomic(struct thunk *t)
{
 return refcount_dec_nonatomic_(&t->refcount_, "./data.h" ":" "1632");
}

static inline _Bool thunk_refcount_is_one_nonatomic(struct thunk *t)
{
 return refcount_is_one_nonatomic_(&t->refcount_, "./data.h" ":" "1637");
}

static inline refcount_int_t thunk_refcount_get_nonatomic(struct thunk *t)
{
 return refcount_get_nonatomic_(&t->refcount_, "./data.h" ":" "1642");
}

static inline void thunk_assert_refcount(struct thunk __attribute__((__unused__)) *t)
{
 ((__builtin_expect((int)(!refcount_is_invalid(&t->refcount_)), 1)) ? (void)0 : internal ("./data.h" ":" "1647", "thunk_assert_refcount: invalid refcount"));
}

pointer_t u_pointer_reference_(pointer_t *ptr , const char __attribute__((__unused__)) *position_arg);

void u_pointer_reference_maybe_(frame_s *fp, frame_t result, pointer_t *ptr, unsigned char flags , const char __attribute__((__unused__)) *position_arg);



static inline _Bool data_is_writable(struct data *d)
{
 return refcount_is_one_(&d->refcount_, "./data.h" ":" "1658");
}

static inline _Bool thunk_is_writable(struct thunk *t)
{
 return refcount_is_one_(&t->refcount_, "./data.h" ":" "1663");
}
# 1679 "./data.h"
static inline pointer_t pointer_locked_read(pointer_t *ptr)
{
 pointer_t ret;
 do { } while (0);
 ret = *((volatile pointer_t *)(ptr));
                      ;
 if (!pointer_is_thunk(ret))
  do { } while (0);
 do { } while (0);
 return ret;
}

static inline void pointer_locked_write(pointer_t *ptr, pointer_t val)
{
                      ;
 do { } while (0);
 *((volatile pointer_t *)(ptr)) = val;
 do { } while (0);
}






void u_copy_from_function_reference_to_frame(frame_s *new_fp, struct data *ref, arg_t ia, char can_move);


void * u_pointer_follow_thunk_(pointer_t *ptr, void *ex_wait);
void u_pointer_resolve_result(pointer_t *ptr);
void u_pointer_follow_wait(frame_s *fp, const code_t *ip);
# 1780 "./data.h"
_Bool u_data_is_nan(type_tag_t type, const unsigned char *ptr);
pointer_t u_flat_to_data(const struct type *type, const unsigned char *flat);
void u_struct_clone(pointer_t *ptr);

void * u_pointer_deep_eval(pointer_t *ptr, frame_s *fp, const code_t *ip, struct thunk **thunk);
void * u_frame_pointer_deep_eval(frame_s *fp, const code_t *ip, frame_t slot, struct thunk **thunk);

_Bool u_mpint_export(const mpint_t *m, unsigned char *ptr, unsigned intx, ajla_error_t *err);
_Bool u_mpint_export_unsigned(const mpint_t *m, unsigned char *ptr, unsigned intx, ajla_error_t *err);

int u_data_compare_numbers(type_tag_t tt, unsigned char *flat1, pointer_t ptr1, unsigned char *flat2, pointer_t ptr2);

int u_data_compare(pointer_t ptr1, pointer_t ptr2, ajla_error_t *mayfail);


static inline _Bool frame_variable_is_flat(frame_s *fp, frame_t slot)
{
 return !frame_test_flag(fp, slot) && ((((((void)(zero_())), ((frame_get_type_of_local(fp, slot))->tag) < 0 + 2 * 5) || (((void)(zero_())), ((frame_get_type_of_local(fp, slot))->tag) >= ((0 + 2 * 5) + 5) && ((frame_get_type_of_local(fp, slot))->tag) < ((0 + 2 * 5) + 5) + 4) || (((void)(zero_())), ((frame_get_type_of_local(fp, slot))->tag) >= (0 + 2 * 5) && ((frame_get_type_of_local(fp, slot))->tag) < (0 + 2 * 5) + 5) || ((frame_get_type_of_local(fp, slot))->tag) == ((((0 + 2 * 5) + 5) + 4) + 0)) || ((frame_get_type_of_local(fp, slot))->tag) == ((((0 + 2 * 5) + 5) + 4) + 3) || ((frame_get_type_of_local(fp, slot))->tag) == ((((0 + 2 * 5) + 5) + 4) + 4)));
}

static inline __attribute__((__always_inline__)) void frame_free(frame_s *fp, frame_t slot)
{
 if (frame_test_and_clear_flag(fp, slot)) {
  u_pointer_dereference_(*(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) , "./data.h" ":" "1803");

  pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))));
 }
}

static inline __attribute__((__always_inline__)) void frame_free_and_clear(frame_s *fp, frame_t slot)
{
 frame_free(fp, slot);
 *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = pointer_empty();
}

static inline __attribute__((__always_inline__)) void frame_free_and_set_pointer(frame_s *fp, frame_t slot, pointer_t ptr)
{
 if (frame_test_and_set_flag(fp, slot))
  u_pointer_dereference_(*(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) , "./data.h" ":" "1818");
 *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = ptr;
}

static inline __attribute__((__always_inline__)) void frame_set_pointer(frame_s *fp, frame_t slot, pointer_t ptr)
{
 ((void)(zero_()));
 frame_set_flag(fp, slot);
 *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = ptr;
}

static inline __attribute__((__always_inline__)) pointer_t frame_get_pointer_reference(frame_s *fp, frame_t slot, _Bool deref)
{
 pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
                      ;
 if (!deref) {
  goto do_ref_owned;
 } else {
  *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = pointer_empty();
  if (!frame_test_and_clear_flag(fp, slot))
do_ref_owned:
   pointer_reference_owned(ptr);
 }
 return ptr;
}






struct stack_entry;

struct stack_entry_type {
 void *(*get_ptr)(struct stack_entry *ste);
 _Bool (*get_properties)(struct stack_entry *ste, size_t *align, size_t *size, struct stack_entry **subptrs, size_t *subptrs_len);
 void (*fixup_after_copy)(void *new_ptr);
 void (*fixup_sub_ptr)(void *loc, uintptr_t offset);
 _Bool wrap_on_save;
};

struct stack_entry {
 const struct stack_entry_type *t;
 void *ptr;
 size_t align;
 size_t size;
};

_Bool u_data_save(void *p, uintptr_t offset, size_t *align, size_t *size, struct stack_entry **subptrs, size_t *subptrs_l);
_Bool u_data_save_init_stack(pointer_t *ptr, struct stack_entry **stk, size_t *stk_l);





void *u_data_trap_lookup(void *ptr);
void u_data_trap_insert(struct data *codegen);
# 25 "ipret.c" 2
# 1 "./array.h" 1
# 23 "./array.h"
# 1 "./arindex.h" 1
# 32 "./arindex.h"
static inline void index_init_from_int(mpint_t *t, int64_t val)
{
 mpint_init_from_int64_t(t, val, ((void*)0));
}

_Bool u_index_export_to_int(const mpint_t *t, int64_t *result);
# 50 "./arindex.h"
static inline void index_alloc_leak_(array_index_t __attribute__((__unused__)) *idx , const char __attribute__((__unused__)) *position_arg)
{



 do { } while (0);
}

static inline void index_free_leak_(array_index_t __attribute__((__unused__)) *idx , const char __attribute__((__unused__)) *position_arg)
{
 do { } while (0);





}

static inline void index_detach_leak(array_index_t __attribute__((__unused__)) *idx)
{





}

static inline uint64_t index_get_value_(array_index_t idx)
{



 return idx;

}

static inline void index_set_value_(array_index_t *idx, uint64_t val)
{




 *idx = val;

}


static inline mpint_t *index_get_mp_(array_index_t idx , const char __attribute__((__unused__)) *position_arg)
{
 ((void)(zero_()));



 return num_to_ptr((uint64_t)(idx << 1));

}


static inline void index_set_mp_(array_index_t *idx, mpint_t *mp , const char __attribute__((__unused__)) *position_arg)
{




 do { if ((__builtin_expect((int)((ptr_to_num(mp) & ((uintptr_t)1 << 0)) != 0), 0))) { if (0) fatal("the allocator returned pointer %p that is not compatible with tag %""l" "u""", (mp), (uintmax_t)((uintptr_t)1 << 0)); else ((void)(zero_())); } } while (0);
 *idx = (uint64_t)(ptr_to_num(mp) >> 1) | ((uint64_t)(-((uint64_t)1 << (8 * sizeof(uint64_t) - 2)) * 2));

}

static inline void index_validate(array_index_t __attribute__((__unused__)) idx , const char __attribute__((__unused__)) *position_arg)
{




}
# 148 "./arindex.h"
static inline _Bool index_is_mp_(array_index_t idx , const char __attribute__((__unused__)) *position_arg)
{
 index_validate(idx , position_arg);
 return (int64_t)index_get_value_(idx) < 0;
}


static inline void index_from_int_(array_index_t *idx, int64_t val , const char __attribute__((__unused__)) *position_arg)
{
 ((void)(zero_()));
 index_alloc_leak_(idx , position_arg);

 index_set_value_(idx, (uint64_t)val);
# 169 "./arindex.h"
}


static inline void index_from_mp_(array_index_t *idx, const mpint_t *mp , const char __attribute__((__unused__)) *position_arg)
{

 int64_t id;
 if (u_index_export_to_int(mp, &id)) {
  ((__builtin_expect((int)(id >= 0), 1)) ? (void)0 : internal ((position_arg), "index_from_mp: the result is negative: %""l" "d""", (intmax_t)id));
  index_set_value_(idx, (uint64_t)id);
 } else

 {
  mpint_t *result;
  result = ((mpint_t *)(void *)(ptrcomp_verify(((void *)(void *)(mem_align_position(sizeof(mpint_t), (((((uintptr_t)1 << 0) * 2)) >= (1) ? ((((uintptr_t)1 << 0) * 2)) : (1)), ((void*)0) , "./arindex.h" ":" "183"))))));
  mpint_alloc_copy_mayfail(result, mp, ((void*)0));
  index_set_mp_(idx, result , "./arindex.h" ":" "185");
 }
 index_alloc_leak_(idx , position_arg);
}

void u_index_free_mp_(array_index_t idx , const char __attribute__((__unused__)) *position_arg);

static inline void index_free_(array_index_t *idx , const char __attribute__((__unused__)) *position_arg)
{
 if ((__builtin_expect((int)(index_is_mp_(*idx , position_arg)), 0)))
  u_index_free_mp_(*idx , position_arg);
# 204 "./arindex.h"
 index_free_leak_(idx , position_arg);
}


static inline void index_free_get_mp_(array_index_t *idx, mpint_t *mp , const char __attribute__((__unused__)) *position_arg)
{
 mpint_t *mp_ptr;
 ((void)(zero_()));
 mp_ptr = index_get_mp_(*idx , position_arg);
 *mp = *mp_ptr;
 mem_free_aligned_position(mp_ptr , "./arindex.h" ":" "214");
 index_set_value_(idx, 0);
 index_free_(idx , position_arg);
}

array_index_t u_index_copy_mp_(array_index_t idx , const char __attribute__((__unused__)) *position_arg);

static inline void index_copy_(array_index_t *idx1, array_index_t idx2 , const char __attribute__((__unused__)) *position_arg)
{
 if ((__builtin_expect((int)(index_is_mp_(idx2 , position_arg)), 0))) {
  *idx1 = u_index_copy_mp_(idx2 , position_arg);
 } else {
  *idx1 = idx2;
 }
 index_alloc_leak_(idx1 , position_arg);
}

_Bool u_index_ge_index_mp_(array_index_t idx1, array_index_t idx2 , const char __attribute__((__unused__)) *position_arg);

static inline _Bool index_ge_index_(array_index_t idx1, array_index_t idx2 , const char __attribute__((__unused__)) *position_arg)
{
 index_validate(idx1 , position_arg);
 index_validate(idx2 , position_arg);
 if ((__builtin_expect((int)((int64_t)(index_get_value_(idx1) & index_get_value_(idx2)) < 0), 0))) {
  return u_index_ge_index_mp_(idx1, idx2 , position_arg);
 }
 return index_get_value_(idx1) >= index_get_value_(idx2);
}

_Bool u_index_eq_index_mp_(array_index_t idx1, array_index_t idx2 , const char __attribute__((__unused__)) *position_arg);

static inline _Bool index_eq_index_(array_index_t idx1, array_index_t idx2 , const char __attribute__((__unused__)) *position_arg)
{
 index_validate(idx1 , position_arg);
 index_validate(idx2 , position_arg);
 if ((__builtin_expect((int)((int64_t)(index_get_value_(idx1) & index_get_value_(idx2)) < 0), 0))) {
  return u_index_eq_index_mp_(idx1, idx2 , position_arg);
 }
 return index_get_value_(idx1) == index_get_value_(idx2);
}


static inline _Bool index_ge_int_(array_index_t idx, int64_t val , const char __attribute__((__unused__)) *position_arg)
{
 index_validate(idx , position_arg);
 ((void)(zero_()));

 return index_get_value_(idx) >= (uint64_t)val;
# 272 "./arindex.h"
}


static inline _Bool index_eq_int_(array_index_t idx, int64_t val , const char __attribute__((__unused__)) *position_arg)
{
 index_validate(idx , position_arg);
 ((void)(zero_()));

 return index_get_value_(idx) == (uint64_t)val;
# 291 "./arindex.h"
}



array_index_t u_index_op_mp_(array_index_t idx2, array_index_t idx3, unsigned flags, ajla_error_t *err , const char __attribute__((__unused__)) *position_arg);

static inline _Bool index_add3_(array_index_t *idx1, array_index_t idx2, array_index_t idx3, ajla_error_t *err , const char __attribute__((__unused__)) *position_arg)
{
 index_validate(idx2 , position_arg);
 index_validate(idx3 , position_arg);
 index_set_value_(idx1, index_get_value_(idx2) + index_get_value_(idx3));
 if ((__builtin_expect((int)((int64_t)(index_get_value_(*idx1) | index_get_value_(idx2) | index_get_value_(idx3)) < 0), 0))) {
  *idx1 = u_index_op_mp_(idx2, idx3, 0x1, err , position_arg);
  return !((*idx1) == (((uint64_t)(-((uint64_t)1 << (8 * sizeof(uint64_t) - 2)) * 2))));
 } else {
  index_alloc_leak_(idx1 , position_arg);
  return 1;
 }
}


static inline void index_sub3_(array_index_t *idx1, array_index_t idx2, array_index_t idx3 , const char __attribute__((__unused__)) *position_arg)
{
 index_validate(idx2 , position_arg);
 index_validate(idx3 , position_arg);
 ((void)(zero_()));
 if ((__builtin_expect((int)(index_is_mp_(idx2 , position_arg)), 0))) {
  *idx1 = u_index_op_mp_(idx2, idx3, 0x1 | 0x2, ((void*)0) , position_arg);
 } else {
  index_set_value_(idx1, index_get_value_(idx2) - index_get_value_(idx3));
  index_alloc_leak_(idx1 , position_arg);
 }
}


static inline _Bool index_add_(array_index_t *idx1, array_index_t idx2, ajla_error_t *err , const char __attribute__((__unused__)) *position_arg)
{
 uint64_t result;
 index_validate(*idx1 , position_arg);
 index_validate(idx2 , position_arg);
 result = index_get_value_(*idx1) + index_get_value_(idx2);
 if ((__builtin_expect((int)((int64_t)(result | index_get_value_(*idx1) | index_get_value_(idx2)) < 0), 0))) {
  *idx1 = u_index_op_mp_(*idx1, idx2, 0, err , position_arg);
  return !((*idx1) == (((uint64_t)(-((uint64_t)1 << (8 * sizeof(uint64_t) - 2)) * 2))));
 } else {
  index_set_value_(idx1, result);
  return 1;
 }
}


static inline void index_sub_(array_index_t *idx1, array_index_t idx2 , const char __attribute__((__unused__)) *position_arg)
{
 index_validate(*idx1 , position_arg);
 index_validate(idx2 , position_arg);
 ((void)(zero_()));
 if ((__builtin_expect((int)(index_is_mp_(*idx1 , position_arg)), 0))) {
  *idx1 = u_index_op_mp_(*idx1, idx2, 0x2, ((void*)0) , position_arg);
 } else {
  index_set_value_(idx1, index_get_value_(*idx1) - index_get_value_(idx2));
 }
}


static inline void index_add_int_(array_index_t *idx1, int64_t val , const char __attribute__((__unused__)) *position_arg)
{
 array_index_t idx2;
 index_from_int_(&idx2, val , position_arg);
 index_add_(idx1, idx2, ((void*)0) , position_arg);



}


static inline void index_sub_int_(array_index_t *idx1, int64_t val , const char __attribute__((__unused__)) *position_arg)
{
 array_index_t idx2;
 index_from_int_(&idx2, val , position_arg);
 index_sub_(idx1, idx2 , position_arg);



}


static inline _Bool index_is_int_(array_index_t idx , const char __attribute__((__unused__)) *position_arg)
{
 if ((__builtin_expect((int)(!index_is_mp_(idx , position_arg)), 1))) {
  return 1;
 } else {





  return 0;
 }
}


static inline int64_t index_to_int_(array_index_t idx , const char __attribute__((__unused__)) *position_arg)
{
 int64_t val;
 index_validate(idx , position_arg);

 val = (int64_t)index_get_value_(idx);


 ((void)(zero_()));






 return val;
}


static inline void index_to_mpint_(array_index_t idx, mpint_t *mp , const char __attribute__((__unused__)) *position_arg)
{
 if (!index_is_mp_(idx , position_arg)) {
  index_init_from_int(mp, (int64_t)index_get_value_(idx));
 } else {
  mpint_alloc_copy_mayfail(mp, index_get_mp_(idx , position_arg), ((void*)0));
 }
}
# 24 "./array.h" 2
# 46 "./array.h"
_Bool u_array_read(struct data *array, array_index_t idx, pointer_t **result_ptr, unsigned char **result_flat, const struct type **flat_type, int64_t *run);

struct data *u_array_clone(pointer_t *ptr, ajla_error_t *err);



_Bool u_array_modify(pointer_t *root, array_index_t idx, unsigned flags, pointer_t **result_ptr, unsigned char **result_flat, const struct type **flat_type, frame_s *fp, const code_t *ip);

array_index_t u_array_len(struct data *array);
_Bool u_array_is_empty(struct data *array);

struct data * u_array_join(struct data *array1, struct data *array2, ajla_error_t *err);
struct data * u_array_sub(struct data *array, array_index_t start, array_index_t len, _Bool deref, ajla_error_t *err);

pointer_t u_array_create(array_index_t length, const struct type *flat_type, const unsigned char *flat, pointer_t ptr);
pointer_t u_array_create_sparse(array_index_t length, pointer_t ptr);
pointer_t u_array_string(int64_t length, const struct type *flat_type, const unsigned char *flat);

void u_array_incomplete_decompose(struct data *array, struct data **first, pointer_t *last);
_Bool u_array_incomplete_collapse(pointer_t *ptr);

struct data * u_array_from_flat_mem(const struct type *type, const char *mem, size_t n_elements, ajla_error_t *mayfail);
# 26 "ipret.c" 2

# 1 "./funct.h" 1
# 31 "./funct.h"
pointer_t u_function_build_internal_thunk(void *(*fn)(frame_s *fp, const code_t *ip, union internal_arg arguments[]), unsigned n_arguments, union internal_arg arguments[]);

struct execution_control *u_function_evaluate_prepare(ajla_error_t *mayfail);
void u_function_evaluate_submit(struct execution_control *ex, pointer_t ptr, void (*callback)(void *, pointer_t), void *callback_cookie);

void * u_function_return(frame_s *fp, pointer_t ptr);

void * u_function_call_internal(frame_s *fp, const code_t *ip);

void u_function_init_common(struct data *fn);
# 28 "ipret.c" 2
# 1 "./arithm-b.h" 1
# 495 "./arithm-b.h"
static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_bsr_alt1_int8_t(const uint8_t *op, uint8_t *res){ int16_t r; __asm__ ("							\n		lzcnt""w""	%1, %0					\n	":"=r"(r):"r"((int16_t)*op):"cc"); *res = (int16_t)(sizeof(int16_t) * 8 - 1 - r); }
static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_bsr_alt1_int16_t(const uint16_t *op, uint16_t *res){ int16_t r; __asm__ ("							\n		lzcnt""w""	%1, %0					\n	":"=r"(r):"r"((int16_t)*op):"cc"); *res = (int16_t)(sizeof(int16_t) * 8 - 1 - r); }
static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_bsr_alt1_int32_t(const uint32_t *op, uint32_t *res){ int32_t r; __asm__ ("							\n		lzcnt""l""	%1, %0					\n	":"=r"(r):"r"((int32_t)*op):"cc"); *res = (int32_t)(sizeof(int32_t) * 8 - 1 - r); }




static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_bsr_alt1_int64_t(const uint64_t *op, uint64_t *res){ int64_t r; __asm__ ("							\n		lzcnt""q""	%1, %0					\n	":"=r"(r):"r"((int64_t)*op):"cc"); *res = (int64_t)(sizeof(int64_t) * 8 - 1 - r); }

static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_bsr_alt1_int128_t(const uint128_t *op, uint128_t *res){ __asm__ ("							\n		test""q""	%%""rdx"", %%""rdx""			\n		cmovz""q""	%%""rax"", %%""rdx""			\n		setz		%%cl					\n		lzcnt""q""	%%""rdx"", %%""rdx""			\n		movl		$""127"", %%eax				\n		shrl		%%cl, %%eax				\n		sub""q""	%%""rdx"", %%""rax""			\n		""cqto""							\n	":"=A"(*res):"0"(*op):"ecx","cc"); }
# 640 "./arithm-b.h"
static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_popcnt_alt1_int8_t(const uint8_t *op, uint8_t *res){ uint16_t r; __asm__ ("							\n		popcnt""w""	%1, %0					\n	":"=r"(r):"r"((uint16_t)*op):"cc"); *res = r; }
static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_popcnt_alt1_int16_t(const uint16_t *op, uint16_t *res){ uint16_t r; __asm__ ("							\n		popcnt""w""	%1, %0					\n	":"=r"(r):"r"((uint16_t)*op):"cc"); *res = r; }
static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_popcnt_alt1_int32_t(const uint32_t *op, uint32_t *res){ uint32_t r; __asm__ ("							\n		popcnt""l""	%1, %0					\n	":"=r"(r):"r"((uint32_t)*op):"cc"); *res = r; }




static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_popcnt_alt1_int64_t(const uint64_t *op, uint64_t *res){ uint64_t r; __asm__ ("							\n		popcnt""q""	%1, %0					\n	":"=r"(r):"r"((uint64_t)*op):"cc"); *res = r; }

static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_popcnt_alt1_int128_t(const uint128_t *op, uint128_t *res){ uint64_t r1, r2; __asm__ ("							\n		popcnt""q""	%1, %0					\n	":"=r"(r1):"r"(((uint64_t *)(void *)(op))[0]):"cc"); __asm__ ("							\n		popcnt""q""	%1, %0					\n	":"=r"(r2):"r"(((uint64_t *)(void *)(op))[1]):"cc"); *res = (unsigned)r1 + (unsigned)r2; }
# 706 "./arithm-b.h"
# 1 "./for-fix.inc" 1
# 24 "./for-fix.inc"
# 1 "./arithm-b.inc" 1
# 30 "./arithm-b.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_divide_int8_t(const uint8_t *op1, const uint8_t *op2, uint8_t *res){ const _Bool mod = !(1 / 1); if ((__builtin_expect((int)(!*op2), 0))) { *res = !mod ? 0 : *op1; return 1; } if (0) { *res = *op1 / *op2; } else if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) { if (sizeof(int8_t) >= sizeof(int) && (__builtin_expect((int)(*op2 == (uint8_t)-1), 0)) && (__builtin_expect((int)(*op1 == ((uint8_t)(-((uint8_t)1 << (8 * sizeof(uint8_t) - 2)) * 2))), 0))) { *res = !mod ? *op1 : 0; return 1; } *res = (int8_t)*op1 / (int8_t)*op2; } else { uint8_t o1 = (int8_t)*op1 < 0 ? -*op1 : *op1; uint8_t o2 = (int8_t)*op2 < 0 ? -*op2 : *op2; uint8_t neg = !mod ? (*op1 ^ *op2) & ((int8_t)(-((int8_t)1 << (8 * sizeof(int8_t) - 2)) * 2)) : (uint8_t)((int8_t)*op1 < 0); uint8_t r = o1 / o2; if ((__builtin_expect((int)(neg != 0), 0))) r = -r; *res = r; } return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_udivide_int8_t(const uint8_t *op1, const uint8_t *op2, uint8_t *res){ const _Bool mod = !(1 / 1); if ((__builtin_expect((int)(!*op2), 0))) { *res = !mod ? 0 : *op1; return 1; } if (1) { *res = *op1 / *op2; } else if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) { if (sizeof(int8_t) >= sizeof(int) && (__builtin_expect((int)(*op2 == (uint8_t)-1), 0)) && (__builtin_expect((int)(*op1 == ((uint8_t)(-((uint8_t)1 << (8 * sizeof(uint8_t) - 2)) * 2))), 0))) { *res = !mod ? *op1 : 0; return 1; } *res = (int8_t)*op1 / (int8_t)*op2; } else { uint8_t o1 = (int8_t)*op1 < 0 ? -*op1 : *op1; uint8_t o2 = (int8_t)*op2 < 0 ? -*op2 : *op2; uint8_t neg = !mod ? (*op1 ^ *op2) & ((int8_t)(-((int8_t)1 << (8 * sizeof(int8_t) - 2)) * 2)) : (uint8_t)((int8_t)*op1 < 0); uint8_t r = o1 / o2; if ((__builtin_expect((int)(neg != 0), 0))) r = -r; *res = r; } return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_modulo_int8_t(const uint8_t *op1, const uint8_t *op2, uint8_t *res){ const _Bool mod = !(1 % 1); if ((__builtin_expect((int)(!*op2), 0))) { *res = !mod ? 0 : *op1; return 1; } if (0) { *res = *op1 % *op2; } else if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) { if (sizeof(int8_t) >= sizeof(int) && (__builtin_expect((int)(*op2 == (uint8_t)-1), 0)) && (__builtin_expect((int)(*op1 == ((uint8_t)(-((uint8_t)1 << (8 * sizeof(uint8_t) - 2)) * 2))), 0))) { *res = !mod ? *op1 : 0; return 1; } *res = (int8_t)*op1 % (int8_t)*op2; } else { uint8_t o1 = (int8_t)*op1 < 0 ? -*op1 : *op1; uint8_t o2 = (int8_t)*op2 < 0 ? -*op2 : *op2; uint8_t neg = !mod ? (*op1 ^ *op2) & ((int8_t)(-((int8_t)1 << (8 * sizeof(int8_t) - 2)) * 2)) : (uint8_t)((int8_t)*op1 < 0); uint8_t r = o1 % o2; if ((__builtin_expect((int)(neg != 0), 0))) r = -r; *res = r; } return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_umodulo_int8_t(const uint8_t *op1, const uint8_t *op2, uint8_t *res){ const _Bool mod = !(1 % 1); if ((__builtin_expect((int)(!*op2), 0))) { *res = !mod ? 0 : *op1; return 1; } if (1) { *res = *op1 % *op2; } else if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) { if (sizeof(int8_t) >= sizeof(int) && (__builtin_expect((int)(*op2 == (uint8_t)-1), 0)) && (__builtin_expect((int)(*op1 == ((uint8_t)(-((uint8_t)1 << (8 * sizeof(uint8_t) - 2)) * 2))), 0))) { *res = !mod ? *op1 : 0; return 1; } *res = (int8_t)*op1 % (int8_t)*op2; } else { uint8_t o1 = (int8_t)*op1 < 0 ? -*op1 : *op1; uint8_t o2 = (int8_t)*op2 < 0 ? -*op2 : *op2; uint8_t neg = !mod ? (*op1 ^ *op2) & ((int8_t)(-((int8_t)1 << (8 * sizeof(int8_t) - 2)) * 2)) : (uint8_t)((int8_t)*op1 < 0); uint8_t r = o1 % o2; if ((__builtin_expect((int)(neg != 0), 0))) r = -r; *res = r; } return 1; }


static _Bool __attribute__((__unused__)) FIXED_binary_power_int8_t(const uint8_t *op1, const uint8_t *op2, uint8_t *res){ uint8_t r = 1; uint8_t o1 = *op1; uint8_t o2 = *op2; do { if (o2 & 1) r *= o1; o1 *= o1; o2 >>= 1; } while (o2); *res = r; return 1; }


static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_rol_int8_t(const uint8_t *op1, const uint8_t *op2, uint8_t *res){ __asm__ ("rol" "b" " %2, %0" : "=q"(*res) : "0"(*op1), "cN"((uint8_t)*op2) : "cc"); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_ror_int8_t(const uint8_t *op1, const uint8_t *op2, uint8_t *res){ __asm__ ("ror" "b" " %2, %0" : "=q"(*res) : "0"(*op1), "cN"((uint8_t)*op2) : "cc"); return 1; }
# 62 "./arithm-b.inc"
static inline __attribute__((__always_inline__)) uint8_t bits_mask_int8_t(uint8_t num) { uint8_t result; __asm__ ("rol""b"" %2, %1":"=q"(result):"0"((uint8_t)1),"c"(num):"cc"); return result; } static inline __attribute__((__always_inline__)) uint8_t bitr_mask_int8_t(uint8_t num) { uint8_t result; __asm__ ("rol""b"" %2, %1":"=q"(result):"0"((uint8_t)-2),"c"(num):"cc"); return result; } static inline __attribute__((__always_inline__)) uint8_t bitt_ror_int8_t(uint8_t val, uint8_t num){ uint8_t result; __asm__ ("ror""b"" %2, %1":"=q"(result):"0"(val),"c"(num):"cc"); return result; }
# 72 "./arithm-b.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_bts_int8_t(const uint8_t *op1, const uint8_t *op2, uint8_t *res){ *res = *op1 | bits_mask_int8_t((uint8_t)*op2); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_btr_int8_t(const uint8_t *op1, const uint8_t *op2, uint8_t *res){ *res = *op1 & bitr_mask_int8_t((uint8_t)*op2); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_btc_int8_t(const uint8_t *op1, const uint8_t *op2, uint8_t *res){ *res = *op1 ^ bits_mask_int8_t((uint8_t)*op2); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_bt_int8_t(const uint8_t *op1, const uint8_t *op2, ajla_flat_option_t *res){ *res = bitt_ror_int8_t(*op1, (uint8_t)*op2) & 1; return 1; }

static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_bswap_int8_t(const uint8_t *op, uint8_t *res){ *res = *op; }
# 83 "./arithm-b.inc"
static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_brev_int8_t(const uint8_t *op, uint8_t *res){ uint8_t one = 1; uint8_t mask; uint8_t o = *op; mask = (uint8_t)((uint8_t)(0x55) * 0x01010101UL * ((one << 15 << 15 << 2) + 1) * ((one << 15 << 15 << 15 << 15 << 4) + 1)); o = ((o & mask) << 1) | ((o & ~mask) >> 1); mask = (uint8_t)((uint8_t)(0x33) * 0x01010101UL * ((one << 15 << 15 << 2) + 1) * ((one << 15 << 15 << 15 << 15 << 4) + 1)); o = ((o & mask) << 2) | ((o & ~mask) >> 2); mask = (uint8_t)((uint8_t)(0x0f) * 0x01010101UL * ((one << 15 << 15 << 2) + 1) * ((one << 15 << 15 << 15 << 15 << 4) + 1)); o = ((o & mask) << 4) | ((o & ~mask) >> 4); FIXED_unary_bswap_int8_t(&o, res); }


static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_bsf_int8_t(const uint8_t *op, uint8_t *res){ int i; uint8_t o = *op; if ((__builtin_expect((int)(!o), 0))) { *res = -1; return; } else { *res = __builtin_ctz(o); return; } for (i = 0; i < (int)sizeof(int8_t) * 8; i++) if (o & ((uint8_t)1 << i)) { *res = (uint8_t)i; return; } *res = (uint8_t)-1; } static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_bsr_int8_t(const uint8_t *op, uint8_t *res){ int i; uint8_t o = *op; if ((__builtin_expect((int)(!o), 0))) { *res = -1; return; } else { *res = ((unsigned)sizeof(unsigned) * 8 - 1) ^ __builtin_clz(o); return; } for (i = (int)sizeof(int8_t) * 8 - 1; i >= 0; i--) if (o & ((uint8_t)1 << i)) { *res = (uint8_t)i; return; } *res = (uint8_t)-1; }
static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_popcnt_int8_t(const uint8_t *op, uint8_t *res){ unsigned r; uint8_t o = *op; *res = (unsigned)__builtin_popcount(o); return; r = 0; while (o) o &= o - 1, r++; *res = (uint8_t)r; }
# 25 "./for-fix.inc" 2
# 36 "./for-fix.inc"
# 1 "./arithm-b.inc" 1
# 30 "./arithm-b.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_divide_int16_t(const uint16_t *op1, const uint16_t *op2, uint16_t *res){ const _Bool mod = !(1 / 1); if ((__builtin_expect((int)(!*op2), 0))) { *res = !mod ? 0 : *op1; return 1; } if (0) { *res = *op1 / *op2; } else if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) { if (sizeof(int16_t) >= sizeof(int) && (__builtin_expect((int)(*op2 == (uint16_t)-1), 0)) && (__builtin_expect((int)(*op1 == ((uint16_t)(-((uint16_t)1 << (8 * sizeof(uint16_t) - 2)) * 2))), 0))) { *res = !mod ? *op1 : 0; return 1; } *res = (int16_t)*op1 / (int16_t)*op2; } else { uint16_t o1 = (int16_t)*op1 < 0 ? -*op1 : *op1; uint16_t o2 = (int16_t)*op2 < 0 ? -*op2 : *op2; uint16_t neg = !mod ? (*op1 ^ *op2) & ((int16_t)(-((int16_t)1 << (8 * sizeof(int16_t) - 2)) * 2)) : (uint16_t)((int16_t)*op1 < 0); uint16_t r = o1 / o2; if ((__builtin_expect((int)(neg != 0), 0))) r = -r; *res = r; } return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_udivide_int16_t(const uint16_t *op1, const uint16_t *op2, uint16_t *res){ const _Bool mod = !(1 / 1); if ((__builtin_expect((int)(!*op2), 0))) { *res = !mod ? 0 : *op1; return 1; } if (1) { *res = *op1 / *op2; } else if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) { if (sizeof(int16_t) >= sizeof(int) && (__builtin_expect((int)(*op2 == (uint16_t)-1), 0)) && (__builtin_expect((int)(*op1 == ((uint16_t)(-((uint16_t)1 << (8 * sizeof(uint16_t) - 2)) * 2))), 0))) { *res = !mod ? *op1 : 0; return 1; } *res = (int16_t)*op1 / (int16_t)*op2; } else { uint16_t o1 = (int16_t)*op1 < 0 ? -*op1 : *op1; uint16_t o2 = (int16_t)*op2 < 0 ? -*op2 : *op2; uint16_t neg = !mod ? (*op1 ^ *op2) & ((int16_t)(-((int16_t)1 << (8 * sizeof(int16_t) - 2)) * 2)) : (uint16_t)((int16_t)*op1 < 0); uint16_t r = o1 / o2; if ((__builtin_expect((int)(neg != 0), 0))) r = -r; *res = r; } return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_modulo_int16_t(const uint16_t *op1, const uint16_t *op2, uint16_t *res){ const _Bool mod = !(1 % 1); if ((__builtin_expect((int)(!*op2), 0))) { *res = !mod ? 0 : *op1; return 1; } if (0) { *res = *op1 % *op2; } else if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) { if (sizeof(int16_t) >= sizeof(int) && (__builtin_expect((int)(*op2 == (uint16_t)-1), 0)) && (__builtin_expect((int)(*op1 == ((uint16_t)(-((uint16_t)1 << (8 * sizeof(uint16_t) - 2)) * 2))), 0))) { *res = !mod ? *op1 : 0; return 1; } *res = (int16_t)*op1 % (int16_t)*op2; } else { uint16_t o1 = (int16_t)*op1 < 0 ? -*op1 : *op1; uint16_t o2 = (int16_t)*op2 < 0 ? -*op2 : *op2; uint16_t neg = !mod ? (*op1 ^ *op2) & ((int16_t)(-((int16_t)1 << (8 * sizeof(int16_t) - 2)) * 2)) : (uint16_t)((int16_t)*op1 < 0); uint16_t r = o1 % o2; if ((__builtin_expect((int)(neg != 0), 0))) r = -r; *res = r; } return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_umodulo_int16_t(const uint16_t *op1, const uint16_t *op2, uint16_t *res){ const _Bool mod = !(1 % 1); if ((__builtin_expect((int)(!*op2), 0))) { *res = !mod ? 0 : *op1; return 1; } if (1) { *res = *op1 % *op2; } else if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) { if (sizeof(int16_t) >= sizeof(int) && (__builtin_expect((int)(*op2 == (uint16_t)-1), 0)) && (__builtin_expect((int)(*op1 == ((uint16_t)(-((uint16_t)1 << (8 * sizeof(uint16_t) - 2)) * 2))), 0))) { *res = !mod ? *op1 : 0; return 1; } *res = (int16_t)*op1 % (int16_t)*op2; } else { uint16_t o1 = (int16_t)*op1 < 0 ? -*op1 : *op1; uint16_t o2 = (int16_t)*op2 < 0 ? -*op2 : *op2; uint16_t neg = !mod ? (*op1 ^ *op2) & ((int16_t)(-((int16_t)1 << (8 * sizeof(int16_t) - 2)) * 2)) : (uint16_t)((int16_t)*op1 < 0); uint16_t r = o1 % o2; if ((__builtin_expect((int)(neg != 0), 0))) r = -r; *res = r; } return 1; }


static _Bool __attribute__((__unused__)) FIXED_binary_power_int16_t(const uint16_t *op1, const uint16_t *op2, uint16_t *res){ uint16_t r = 1; uint16_t o1 = *op1; uint16_t o2 = *op2; do { if (o2 & 1) r *= o1; o1 *= o1; o2 >>= 1; } while (o2); *res = r; return 1; }





static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_rol_int16_t(const uint16_t *op1, const uint16_t *op2, uint16_t *res){ __asm__ ("rol" "w" " %2, %0" : "=r"(*res) : "0"(*op1), "cN"((uint8_t)*op2) : "cc"); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_ror_int16_t(const uint16_t *op1, const uint16_t *op2, uint16_t *res){ __asm__ ("ror" "w" " %2, %0" : "=r"(*res) : "0"(*op1), "cN"((uint8_t)*op2) : "cc"); return 1; }
# 64 "./arithm-b.inc"
static inline __attribute__((__always_inline__)) uint16_t bits_mask_int16_t(uint8_t num) { uint16_t result; __asm__ ("rol""w"" %2, %1":"=r"(result):"0"((uint16_t)1),"c"(num):"cc"); return result; } static inline __attribute__((__always_inline__)) uint16_t bitr_mask_int16_t(uint8_t num) { uint16_t result; __asm__ ("rol""w"" %2, %1":"=r"(result):"0"((uint16_t)-2),"c"(num):"cc"); return result; } static inline __attribute__((__always_inline__)) uint16_t bitt_ror_int16_t(uint16_t val, uint8_t num){ uint16_t result; __asm__ ("ror""w"" %2, %1":"=r"(result):"0"(val),"c"(num):"cc"); return result; }







static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_bts_int16_t(const uint16_t *op1, const uint16_t *op2, uint16_t *res){ *res = *op1 | bits_mask_int16_t((uint8_t)*op2); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_btr_int16_t(const uint16_t *op1, const uint16_t *op2, uint16_t *res){ *res = *op1 & bitr_mask_int16_t((uint8_t)*op2); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_btc_int16_t(const uint16_t *op1, const uint16_t *op2, uint16_t *res){ *res = *op1 ^ bits_mask_int16_t((uint8_t)*op2); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_bt_int16_t(const uint16_t *op1, const uint16_t *op2, ajla_flat_option_t *res){ *res = bitt_ror_int16_t(*op1, (uint8_t)*op2) & 1; return 1; }

static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_bswap_int16_t(const uint16_t *op, uint16_t *res){ *res = (*op << 8 | *op >> 8); }
# 83 "./arithm-b.inc"
static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_brev_int16_t(const uint16_t *op, uint16_t *res){ uint16_t one = 1; uint16_t mask; uint16_t o = *op; mask = (uint16_t)((uint16_t)(0x55) * 0x01010101UL * ((one << 15 << 15 << 2) + 1) * ((one << 15 << 15 << 15 << 15 << 4) + 1)); o = ((o & mask) << 1) | ((o & ~mask) >> 1); mask = (uint16_t)((uint16_t)(0x33) * 0x01010101UL * ((one << 15 << 15 << 2) + 1) * ((one << 15 << 15 << 15 << 15 << 4) + 1)); o = ((o & mask) << 2) | ((o & ~mask) >> 2); mask = (uint16_t)((uint16_t)(0x0f) * 0x01010101UL * ((one << 15 << 15 << 2) + 1) * ((one << 15 << 15 << 15 << 15 << 4) + 1)); o = ((o & mask) << 4) | ((o & ~mask) >> 4); FIXED_unary_bswap_int16_t(&o, res); }


static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_bsf_int16_t(const uint16_t *op, uint16_t *res){ int i; uint16_t o = *op; if ((__builtin_expect((int)(!o), 0))) { *res = -1; return; } else { *res = __builtin_ctz(o); return; } for (i = 0; i < (int)sizeof(int16_t) * 8; i++) if (o & ((uint16_t)1 << i)) { *res = (uint16_t)i; return; } *res = (uint16_t)-1; } static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_bsr_int16_t(const uint16_t *op, uint16_t *res){ int i; uint16_t o = *op; if ((__builtin_expect((int)(!o), 0))) { *res = -1; return; } else { *res = ((unsigned)sizeof(unsigned) * 8 - 1) ^ __builtin_clz(o); return; } for (i = (int)sizeof(int16_t) * 8 - 1; i >= 0; i--) if (o & ((uint16_t)1 << i)) { *res = (uint16_t)i; return; } *res = (uint16_t)-1; }
static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_popcnt_int16_t(const uint16_t *op, uint16_t *res){ unsigned r; uint16_t o = *op; *res = (unsigned)__builtin_popcount(o); return; r = 0; while (o) o &= o - 1, r++; *res = (uint16_t)r; }
# 37 "./for-fix.inc" 2
# 48 "./for-fix.inc"
# 1 "./arithm-b.inc" 1
# 30 "./arithm-b.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_divide_int32_t(const uint32_t *op1, const uint32_t *op2, uint32_t *res){ const _Bool mod = !(1 / 1); if ((__builtin_expect((int)(!*op2), 0))) { *res = !mod ? 0 : *op1; return 1; } if (0) { *res = *op1 / *op2; } else if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) { if (sizeof(int32_t) >= sizeof(int) && (__builtin_expect((int)(*op2 == (uint32_t)-1), 0)) && (__builtin_expect((int)(*op1 == ((uint32_t)(-((uint32_t)1 << (8 * sizeof(uint32_t) - 2)) * 2))), 0))) { *res = !mod ? *op1 : 0; return 1; } *res = (int32_t)*op1 / (int32_t)*op2; } else { uint32_t o1 = (int32_t)*op1 < 0 ? -*op1 : *op1; uint32_t o2 = (int32_t)*op2 < 0 ? -*op2 : *op2; uint32_t neg = !mod ? (*op1 ^ *op2) & ((int32_t)(-((int32_t)1 << (8 * sizeof(int32_t) - 2)) * 2)) : (uint32_t)((int32_t)*op1 < 0); uint32_t r = o1 / o2; if ((__builtin_expect((int)(neg != 0), 0))) r = -r; *res = r; } return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_udivide_int32_t(const uint32_t *op1, const uint32_t *op2, uint32_t *res){ const _Bool mod = !(1 / 1); if ((__builtin_expect((int)(!*op2), 0))) { *res = !mod ? 0 : *op1; return 1; } if (1) { *res = *op1 / *op2; } else if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) { if (sizeof(int32_t) >= sizeof(int) && (__builtin_expect((int)(*op2 == (uint32_t)-1), 0)) && (__builtin_expect((int)(*op1 == ((uint32_t)(-((uint32_t)1 << (8 * sizeof(uint32_t) - 2)) * 2))), 0))) { *res = !mod ? *op1 : 0; return 1; } *res = (int32_t)*op1 / (int32_t)*op2; } else { uint32_t o1 = (int32_t)*op1 < 0 ? -*op1 : *op1; uint32_t o2 = (int32_t)*op2 < 0 ? -*op2 : *op2; uint32_t neg = !mod ? (*op1 ^ *op2) & ((int32_t)(-((int32_t)1 << (8 * sizeof(int32_t) - 2)) * 2)) : (uint32_t)((int32_t)*op1 < 0); uint32_t r = o1 / o2; if ((__builtin_expect((int)(neg != 0), 0))) r = -r; *res = r; } return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_modulo_int32_t(const uint32_t *op1, const uint32_t *op2, uint32_t *res){ const _Bool mod = !(1 % 1); if ((__builtin_expect((int)(!*op2), 0))) { *res = !mod ? 0 : *op1; return 1; } if (0) { *res = *op1 % *op2; } else if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) { if (sizeof(int32_t) >= sizeof(int) && (__builtin_expect((int)(*op2 == (uint32_t)-1), 0)) && (__builtin_expect((int)(*op1 == ((uint32_t)(-((uint32_t)1 << (8 * sizeof(uint32_t) - 2)) * 2))), 0))) { *res = !mod ? *op1 : 0; return 1; } *res = (int32_t)*op1 % (int32_t)*op2; } else { uint32_t o1 = (int32_t)*op1 < 0 ? -*op1 : *op1; uint32_t o2 = (int32_t)*op2 < 0 ? -*op2 : *op2; uint32_t neg = !mod ? (*op1 ^ *op2) & ((int32_t)(-((int32_t)1 << (8 * sizeof(int32_t) - 2)) * 2)) : (uint32_t)((int32_t)*op1 < 0); uint32_t r = o1 % o2; if ((__builtin_expect((int)(neg != 0), 0))) r = -r; *res = r; } return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_umodulo_int32_t(const uint32_t *op1, const uint32_t *op2, uint32_t *res){ const _Bool mod = !(1 % 1); if ((__builtin_expect((int)(!*op2), 0))) { *res = !mod ? 0 : *op1; return 1; } if (1) { *res = *op1 % *op2; } else if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) { if (sizeof(int32_t) >= sizeof(int) && (__builtin_expect((int)(*op2 == (uint32_t)-1), 0)) && (__builtin_expect((int)(*op1 == ((uint32_t)(-((uint32_t)1 << (8 * sizeof(uint32_t) - 2)) * 2))), 0))) { *res = !mod ? *op1 : 0; return 1; } *res = (int32_t)*op1 % (int32_t)*op2; } else { uint32_t o1 = (int32_t)*op1 < 0 ? -*op1 : *op1; uint32_t o2 = (int32_t)*op2 < 0 ? -*op2 : *op2; uint32_t neg = !mod ? (*op1 ^ *op2) & ((int32_t)(-((int32_t)1 << (8 * sizeof(int32_t) - 2)) * 2)) : (uint32_t)((int32_t)*op1 < 0); uint32_t r = o1 % o2; if ((__builtin_expect((int)(neg != 0), 0))) r = -r; *res = r; } return 1; }


static _Bool __attribute__((__unused__)) FIXED_binary_power_int32_t(const uint32_t *op1, const uint32_t *op2, uint32_t *res){ uint32_t r = 1; uint32_t o1 = *op1; uint32_t o2 = *op2; do { if (o2 & 1) r *= o1; o1 *= o1; o2 >>= 1; } while (o2); *res = r; return 1; }
# 42 "./arithm-b.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_rol_int32_t(const uint32_t *op1, const uint32_t *op2, uint32_t *res){ __asm__ ("rol" "l" " %2, %0" : "=r"(*res) : "0"(*op1), "cN"((uint8_t)*op2) : "cc"); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_ror_int32_t(const uint32_t *op1, const uint32_t *op2, uint32_t *res){ __asm__ ("ror" "l" " %2, %0" : "=r"(*res) : "0"(*op1), "cN"((uint8_t)*op2) : "cc"); return 1; }
# 66 "./arithm-b.inc"
static inline __attribute__((__always_inline__)) uint32_t bits_mask_int32_t(uint8_t num) { uint32_t result; __asm__ ("rol""l"" %2, %1":"=r"(result):"0"((uint32_t)1),"c"(num):"cc"); return result; } static inline __attribute__((__always_inline__)) uint32_t bitr_mask_int32_t(uint8_t num) { uint32_t result; __asm__ ("rol""l"" %2, %1":"=r"(result):"0"((uint32_t)-2),"c"(num):"cc"); return result; } static inline __attribute__((__always_inline__)) uint32_t bitt_ror_int32_t(uint32_t val, uint8_t num){ uint32_t result; __asm__ ("ror""l"" %2, %1":"=r"(result):"0"(val),"c"(num):"cc"); return result; }





static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_bts_int32_t(const uint32_t *op1, const uint32_t *op2, uint32_t *res){ *res = *op1 | bits_mask_int32_t((uint8_t)*op2); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_btr_int32_t(const uint32_t *op1, const uint32_t *op2, uint32_t *res){ *res = *op1 & bitr_mask_int32_t((uint8_t)*op2); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_btc_int32_t(const uint32_t *op1, const uint32_t *op2, uint32_t *res){ *res = *op1 ^ bits_mask_int32_t((uint8_t)*op2); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_bt_int32_t(const uint32_t *op1, const uint32_t *op2, ajla_flat_option_t *res){ *res = bitt_ror_int32_t(*op1, (uint8_t)*op2) & 1; return 1; }

static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_bswap_int32_t(const uint32_t *op, uint32_t *res){ *res = __builtin_bswap32(*op); }
# 83 "./arithm-b.inc"
static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_brev_int32_t(const uint32_t *op, uint32_t *res){ uint32_t one = 1; uint32_t mask; uint32_t o = *op; mask = (uint32_t)((uint32_t)(0x55) * 0x01010101UL * ((one << 15 << 15 << 2) + 1) * ((one << 15 << 15 << 15 << 15 << 4) + 1)); o = ((o & mask) << 1) | ((o & ~mask) >> 1); mask = (uint32_t)((uint32_t)(0x33) * 0x01010101UL * ((one << 15 << 15 << 2) + 1) * ((one << 15 << 15 << 15 << 15 << 4) + 1)); o = ((o & mask) << 2) | ((o & ~mask) >> 2); mask = (uint32_t)((uint32_t)(0x0f) * 0x01010101UL * ((one << 15 << 15 << 2) + 1) * ((one << 15 << 15 << 15 << 15 << 4) + 1)); o = ((o & mask) << 4) | ((o & ~mask) >> 4); FIXED_unary_bswap_int32_t(&o, res); }


static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_bsf_int32_t(const uint32_t *op, uint32_t *res){ int i; uint32_t o = *op; if ((__builtin_expect((int)(!o), 0))) { *res = -1; return; } else { *res = __builtin_ctz(o); return; } for (i = 0; i < (int)sizeof(int32_t) * 8; i++) if (o & ((uint32_t)1 << i)) { *res = (uint32_t)i; return; } *res = (uint32_t)-1; } static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_bsr_int32_t(const uint32_t *op, uint32_t *res){ int i; uint32_t o = *op; if ((__builtin_expect((int)(!o), 0))) { *res = -1; return; } else { *res = ((unsigned)sizeof(unsigned) * 8 - 1) ^ __builtin_clz(o); return; } for (i = (int)sizeof(int32_t) * 8 - 1; i >= 0; i--) if (o & ((uint32_t)1 << i)) { *res = (uint32_t)i; return; } *res = (uint32_t)-1; }
static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_popcnt_int32_t(const uint32_t *op, uint32_t *res){ unsigned r; uint32_t o = *op; *res = (unsigned)__builtin_popcount(o); return; r = 0; while (o) o &= o - 1, r++; *res = (uint32_t)r; }
# 49 "./for-fix.inc" 2
# 60 "./for-fix.inc"
# 1 "./arithm-b.inc" 1
# 30 "./arithm-b.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_divide_int64_t(const uint64_t *op1, const uint64_t *op2, uint64_t *res){ const _Bool mod = !(1 / 1); if ((__builtin_expect((int)(!*op2), 0))) { *res = !mod ? 0 : *op1; return 1; } if (0) { *res = *op1 / *op2; } else if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) { if (sizeof(int64_t) >= sizeof(int) && (__builtin_expect((int)(*op2 == (uint64_t)-1), 0)) && (__builtin_expect((int)(*op1 == ((uint64_t)(-((uint64_t)1 << (8 * sizeof(uint64_t) - 2)) * 2))), 0))) { *res = !mod ? *op1 : 0; return 1; } *res = (int64_t)*op1 / (int64_t)*op2; } else { uint64_t o1 = (int64_t)*op1 < 0 ? -*op1 : *op1; uint64_t o2 = (int64_t)*op2 < 0 ? -*op2 : *op2; uint64_t neg = !mod ? (*op1 ^ *op2) & ((int64_t)(-((int64_t)1 << (8 * sizeof(int64_t) - 2)) * 2)) : (uint64_t)((int64_t)*op1 < 0); uint64_t r = o1 / o2; if ((__builtin_expect((int)(neg != 0), 0))) r = -r; *res = r; } return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_udivide_int64_t(const uint64_t *op1, const uint64_t *op2, uint64_t *res){ const _Bool mod = !(1 / 1); if ((__builtin_expect((int)(!*op2), 0))) { *res = !mod ? 0 : *op1; return 1; } if (1) { *res = *op1 / *op2; } else if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) { if (sizeof(int64_t) >= sizeof(int) && (__builtin_expect((int)(*op2 == (uint64_t)-1), 0)) && (__builtin_expect((int)(*op1 == ((uint64_t)(-((uint64_t)1 << (8 * sizeof(uint64_t) - 2)) * 2))), 0))) { *res = !mod ? *op1 : 0; return 1; } *res = (int64_t)*op1 / (int64_t)*op2; } else { uint64_t o1 = (int64_t)*op1 < 0 ? -*op1 : *op1; uint64_t o2 = (int64_t)*op2 < 0 ? -*op2 : *op2; uint64_t neg = !mod ? (*op1 ^ *op2) & ((int64_t)(-((int64_t)1 << (8 * sizeof(int64_t) - 2)) * 2)) : (uint64_t)((int64_t)*op1 < 0); uint64_t r = o1 / o2; if ((__builtin_expect((int)(neg != 0), 0))) r = -r; *res = r; } return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_modulo_int64_t(const uint64_t *op1, const uint64_t *op2, uint64_t *res){ const _Bool mod = !(1 % 1); if ((__builtin_expect((int)(!*op2), 0))) { *res = !mod ? 0 : *op1; return 1; } if (0) { *res = *op1 % *op2; } else if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) { if (sizeof(int64_t) >= sizeof(int) && (__builtin_expect((int)(*op2 == (uint64_t)-1), 0)) && (__builtin_expect((int)(*op1 == ((uint64_t)(-((uint64_t)1 << (8 * sizeof(uint64_t) - 2)) * 2))), 0))) { *res = !mod ? *op1 : 0; return 1; } *res = (int64_t)*op1 % (int64_t)*op2; } else { uint64_t o1 = (int64_t)*op1 < 0 ? -*op1 : *op1; uint64_t o2 = (int64_t)*op2 < 0 ? -*op2 : *op2; uint64_t neg = !mod ? (*op1 ^ *op2) & ((int64_t)(-((int64_t)1 << (8 * sizeof(int64_t) - 2)) * 2)) : (uint64_t)((int64_t)*op1 < 0); uint64_t r = o1 % o2; if ((__builtin_expect((int)(neg != 0), 0))) r = -r; *res = r; } return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_umodulo_int64_t(const uint64_t *op1, const uint64_t *op2, uint64_t *res){ const _Bool mod = !(1 % 1); if ((__builtin_expect((int)(!*op2), 0))) { *res = !mod ? 0 : *op1; return 1; } if (1) { *res = *op1 % *op2; } else if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) { if (sizeof(int64_t) >= sizeof(int) && (__builtin_expect((int)(*op2 == (uint64_t)-1), 0)) && (__builtin_expect((int)(*op1 == ((uint64_t)(-((uint64_t)1 << (8 * sizeof(uint64_t) - 2)) * 2))), 0))) { *res = !mod ? *op1 : 0; return 1; } *res = (int64_t)*op1 % (int64_t)*op2; } else { uint64_t o1 = (int64_t)*op1 < 0 ? -*op1 : *op1; uint64_t o2 = (int64_t)*op2 < 0 ? -*op2 : *op2; uint64_t neg = !mod ? (*op1 ^ *op2) & ((int64_t)(-((int64_t)1 << (8 * sizeof(int64_t) - 2)) * 2)) : (uint64_t)((int64_t)*op1 < 0); uint64_t r = o1 % o2; if ((__builtin_expect((int)(neg != 0), 0))) r = -r; *res = r; } return 1; }


static _Bool __attribute__((__unused__)) FIXED_binary_power_int64_t(const uint64_t *op1, const uint64_t *op2, uint64_t *res){ uint64_t r = 1; uint64_t o1 = *op1; uint64_t o2 = *op2; do { if (o2 & 1) r *= o1; o1 *= o1; o2 >>= 1; } while (o2); *res = r; return 1; }
# 45 "./arithm-b.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_rol_int64_t(const uint64_t *op1, const uint64_t *op2, uint64_t *res){ __asm__ ("rol" "q" " %2, %0" : "=r"(*res) : "0"(*op1), "cN"((uint8_t)*op2) : "cc"); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_ror_int64_t(const uint64_t *op1, const uint64_t *op2, uint64_t *res){ __asm__ ("ror" "q" " %2, %0" : "=r"(*res) : "0"(*op1), "cN"((uint8_t)*op2) : "cc"); return 1; }
# 68 "./arithm-b.inc"
static inline __attribute__((__always_inline__)) uint64_t bits_mask_int64_t(uint8_t num) { uint64_t result; __asm__ ("rol""q"" %2, %1":"=r"(result):"0"((uint64_t)1),"c"(num):"cc"); return result; } static inline __attribute__((__always_inline__)) uint64_t bitr_mask_int64_t(uint8_t num) { uint64_t result; __asm__ ("rol""q"" %2, %1":"=r"(result):"0"((uint64_t)-2),"c"(num):"cc"); return result; } static inline __attribute__((__always_inline__)) uint64_t bitt_ror_int64_t(uint64_t val, uint8_t num){ uint64_t result; __asm__ ("ror""q"" %2, %1":"=r"(result):"0"(val),"c"(num):"cc"); return result; }



static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_bts_int64_t(const uint64_t *op1, const uint64_t *op2, uint64_t *res){ *res = *op1 | bits_mask_int64_t((uint8_t)*op2); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_btr_int64_t(const uint64_t *op1, const uint64_t *op2, uint64_t *res){ *res = *op1 & bitr_mask_int64_t((uint8_t)*op2); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_btc_int64_t(const uint64_t *op1, const uint64_t *op2, uint64_t *res){ *res = *op1 ^ bits_mask_int64_t((uint8_t)*op2); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) FIXED_binary_bt_int64_t(const uint64_t *op1, const uint64_t *op2, ajla_flat_option_t *res){ *res = bitt_ror_int64_t(*op1, (uint8_t)*op2) & 1; return 1; }

static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_bswap_int64_t(const uint64_t *op, uint64_t *res){ *res = __builtin_bswap64(*op); }
# 83 "./arithm-b.inc"
static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_brev_int64_t(const uint64_t *op, uint64_t *res){ uint64_t one = 1; uint64_t mask; uint64_t o = *op; mask = (uint64_t)((uint64_t)(0x55) * 0x01010101UL * ((one << 15 << 15 << 2) + 1) * ((one << 15 << 15 << 15 << 15 << 4) + 1)); o = ((o & mask) << 1) | ((o & ~mask) >> 1); mask = (uint64_t)((uint64_t)(0x33) * 0x01010101UL * ((one << 15 << 15 << 2) + 1) * ((one << 15 << 15 << 15 << 15 << 4) + 1)); o = ((o & mask) << 2) | ((o & ~mask) >> 2); mask = (uint64_t)((uint64_t)(0x0f) * 0x01010101UL * ((one << 15 << 15 << 2) + 1) * ((one << 15 << 15 << 15 << 15 << 4) + 1)); o = ((o & mask) << 4) | ((o & ~mask) >> 4); FIXED_unary_bswap_int64_t(&o, res); }


static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_bsf_int64_t(const uint64_t *op, uint64_t *res){ int i; uint64_t o = *op; if ((__builtin_expect((int)(!o), 0))) { *res = -1; return; } else { *res = __builtin_ctzll(o); return; } for (i = 0; i < (int)sizeof(int64_t) * 8; i++) if (o & ((uint64_t)1 << i)) { *res = (uint64_t)i; return; } *res = (uint64_t)-1; } static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_bsr_int64_t(const uint64_t *op, uint64_t *res){ int i; uint64_t o = *op; if ((__builtin_expect((int)(!o), 0))) { *res = -1; return; } else { *res = ((unsigned)sizeof(unsigned long long) * 8 - 1) ^ __builtin_clzll(o); return; } for (i = (int)sizeof(int64_t) * 8 - 1; i >= 0; i--) if (o & ((uint64_t)1 << i)) { *res = (uint64_t)i; return; } *res = (uint64_t)-1; }
static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_popcnt_int64_t(const uint64_t *op, uint64_t *res){ unsigned r; uint64_t o = *op; *res = (unsigned)__builtin_popcountll(o); return; r = 0; while (o) o &= o - 1, r++; *res = (uint64_t)r; }
# 61 "./for-fix.inc" 2
# 72 "./for-fix.inc"
# 1 "./arithm-b.inc" 1
# 30 "./arithm-b.inc"
static _Bool __attribute__((__unused__)) FIXED_binary_divide_int128_t(const uint128_t *op1, const uint128_t *op2, uint128_t *res){ const _Bool mod = !(1 / 1); if ((__builtin_expect((int)(!*op2), 0))) { *res = !mod ? 0 : *op1; return 1; } if (0) { *res = *op1 / *op2; } else if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) { if (sizeof(int128_t) >= sizeof(int) && (__builtin_expect((int)(*op2 == (uint128_t)-1), 0)) && (__builtin_expect((int)(*op1 == ((uint128_t)(-((uint128_t)1 << (8 * sizeof(uint128_t) - 2)) * 2))), 0))) { *res = !mod ? *op1 : 0; return 1; } *res = (int128_t)*op1 / (int128_t)*op2; } else { uint128_t o1 = (int128_t)*op1 < 0 ? -*op1 : *op1; uint128_t o2 = (int128_t)*op2 < 0 ? -*op2 : *op2; uint128_t neg = !mod ? (*op1 ^ *op2) & ((int128_t)(-((int128_t)1 << (8 * sizeof(int128_t) - 2)) * 2)) : (uint128_t)((int128_t)*op1 < 0); uint128_t r = o1 / o2; if ((__builtin_expect((int)(neg != 0), 0))) r = -r; *res = r; } return 1; } static _Bool __attribute__((__unused__)) FIXED_binary_udivide_int128_t(const uint128_t *op1, const uint128_t *op2, uint128_t *res){ const _Bool mod = !(1 / 1); if ((__builtin_expect((int)(!*op2), 0))) { *res = !mod ? 0 : *op1; return 1; } if (1) { *res = *op1 / *op2; } else if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) { if (sizeof(int128_t) >= sizeof(int) && (__builtin_expect((int)(*op2 == (uint128_t)-1), 0)) && (__builtin_expect((int)(*op1 == ((uint128_t)(-((uint128_t)1 << (8 * sizeof(uint128_t) - 2)) * 2))), 0))) { *res = !mod ? *op1 : 0; return 1; } *res = (int128_t)*op1 / (int128_t)*op2; } else { uint128_t o1 = (int128_t)*op1 < 0 ? -*op1 : *op1; uint128_t o2 = (int128_t)*op2 < 0 ? -*op2 : *op2; uint128_t neg = !mod ? (*op1 ^ *op2) & ((int128_t)(-((int128_t)1 << (8 * sizeof(int128_t) - 2)) * 2)) : (uint128_t)((int128_t)*op1 < 0); uint128_t r = o1 / o2; if ((__builtin_expect((int)(neg != 0), 0))) r = -r; *res = r; } return 1; } static _Bool __attribute__((__unused__)) FIXED_binary_modulo_int128_t(const uint128_t *op1, const uint128_t *op2, uint128_t *res){ const _Bool mod = !(1 % 1); if ((__builtin_expect((int)(!*op2), 0))) { *res = !mod ? 0 : *op1; return 1; } if (0) { *res = *op1 % *op2; } else if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) { if (sizeof(int128_t) >= sizeof(int) && (__builtin_expect((int)(*op2 == (uint128_t)-1), 0)) && (__builtin_expect((int)(*op1 == ((uint128_t)(-((uint128_t)1 << (8 * sizeof(uint128_t) - 2)) * 2))), 0))) { *res = !mod ? *op1 : 0; return 1; } *res = (int128_t)*op1 % (int128_t)*op2; } else { uint128_t o1 = (int128_t)*op1 < 0 ? -*op1 : *op1; uint128_t o2 = (int128_t)*op2 < 0 ? -*op2 : *op2; uint128_t neg = !mod ? (*op1 ^ *op2) & ((int128_t)(-((int128_t)1 << (8 * sizeof(int128_t) - 2)) * 2)) : (uint128_t)((int128_t)*op1 < 0); uint128_t r = o1 % o2; if ((__builtin_expect((int)(neg != 0), 0))) r = -r; *res = r; } return 1; } static _Bool __attribute__((__unused__)) FIXED_binary_umodulo_int128_t(const uint128_t *op1, const uint128_t *op2, uint128_t *res){ const _Bool mod = !(1 % 1); if ((__builtin_expect((int)(!*op2), 0))) { *res = !mod ? 0 : *op1; return 1; } if (1) { *res = *op1 % *op2; } else if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) { if (sizeof(int128_t) >= sizeof(int) && (__builtin_expect((int)(*op2 == (uint128_t)-1), 0)) && (__builtin_expect((int)(*op1 == ((uint128_t)(-((uint128_t)1 << (8 * sizeof(uint128_t) - 2)) * 2))), 0))) { *res = !mod ? *op1 : 0; return 1; } *res = (int128_t)*op1 % (int128_t)*op2; } else { uint128_t o1 = (int128_t)*op1 < 0 ? -*op1 : *op1; uint128_t o2 = (int128_t)*op2 < 0 ? -*op2 : *op2; uint128_t neg = !mod ? (*op1 ^ *op2) & ((int128_t)(-((int128_t)1 << (8 * sizeof(int128_t) - 2)) * 2)) : (uint128_t)((int128_t)*op1 < 0); uint128_t r = o1 % o2; if ((__builtin_expect((int)(neg != 0), 0))) r = -r; *res = r; } return 1; }


static _Bool __attribute__((__unused__)) FIXED_binary_power_int128_t(const uint128_t *op1, const uint128_t *op2, uint128_t *res){ uint128_t r = 1; uint128_t o1 = *op1; uint128_t o2 = *op2; do { if (o2 & 1) r *= o1; o1 *= o1; o2 >>= 1; } while (o2); *res = r; return 1; }
# 57 "./arithm-b.inc"
static _Bool __attribute__((__unused__)) FIXED_binary_rol_int128_t(const uint128_t *op1, const uint128_t *op2, uint128_t *res){ const uint8_t mask = sizeof(int128_t) * 8 - 1; if (!(0)) *res = (*op1 << (*op2 & mask)) | (*op1 >> (-*op2 & mask)); else *res = (*op1 >> (*op2 & mask)) | (*op1 << (-*op2 & mask)); return 1; }
static _Bool __attribute__((__unused__)) FIXED_binary_ror_int128_t(const uint128_t *op1, const uint128_t *op2, uint128_t *res){ const uint8_t mask = sizeof(int128_t) * 8 - 1; if (!(1)) *res = (*op1 << (*op2 & mask)) | (*op1 >> (-*op2 & mask)); else *res = (*op1 >> (*op2 & mask)) | (*op1 << (-*op2 & mask)); return 1; }
# 70 "./arithm-b.inc"
static inline __attribute__((__always_inline__)) uint128_t bits_mask_int128_t(uint8_t num) { return (uint128_t)1 << (num & (sizeof(int128_t) * 8 - 1)); } static inline __attribute__((__always_inline__)) uint128_t bitr_mask_int128_t(uint8_t num) { return ~((uint128_t)1 << (num & (sizeof(int128_t) * 8 - 1))); } static inline __attribute__((__always_inline__)) uint128_t bitt_ror_int128_t(uint128_t val, uint8_t num){ return val >> ((num & (sizeof(int128_t) * 8 - 1))); }

static _Bool __attribute__((__unused__)) FIXED_binary_bts_int128_t(const uint128_t *op1, const uint128_t *op2, uint128_t *res){ *res = *op1 | bits_mask_int128_t((uint8_t)*op2); return 1; } static _Bool __attribute__((__unused__)) FIXED_binary_btr_int128_t(const uint128_t *op1, const uint128_t *op2, uint128_t *res){ *res = *op1 & bitr_mask_int128_t((uint8_t)*op2); return 1; } static _Bool __attribute__((__unused__)) FIXED_binary_btc_int128_t(const uint128_t *op1, const uint128_t *op2, uint128_t *res){ *res = *op1 ^ bits_mask_int128_t((uint8_t)*op2); return 1; } static _Bool __attribute__((__unused__)) FIXED_binary_bt_int128_t(const uint128_t *op1, const uint128_t *op2, ajla_flat_option_t *res){ *res = bitt_ror_int128_t(*op1, (uint8_t)*op2) & 1; return 1; }

static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) FIXED_unary_bswap_int128_t(const uint128_t *op, uint128_t *res){ uint64_t o_lo = *op; uint64_t o_hi = *op >> 64; FIXED_unary_bswap_int64_t(&o_lo, &o_lo); FIXED_unary_bswap_int64_t(&o_hi, &o_hi); *res = o_hi | ((uint128_t)o_lo << 64); }
# 83 "./arithm-b.inc"
static void __attribute__((__unused__)) FIXED_unary_brev_int128_t(const uint128_t *op, uint128_t *res){ uint128_t one = 1; uint128_t mask; uint128_t o = *op; mask = (uint128_t)((uint128_t)(0x55) * 0x01010101UL * ((one << 15 << 15 << 2) + 1) * ((one << 15 << 15 << 15 << 15 << 4) + 1)); o = ((o & mask) << 1) | ((o & ~mask) >> 1); mask = (uint128_t)((uint128_t)(0x33) * 0x01010101UL * ((one << 15 << 15 << 2) + 1) * ((one << 15 << 15 << 15 << 15 << 4) + 1)); o = ((o & mask) << 2) | ((o & ~mask) >> 2); mask = (uint128_t)((uint128_t)(0x0f) * 0x01010101UL * ((one << 15 << 15 << 2) + 1) * ((one << 15 << 15 << 15 << 15 << 4) + 1)); o = ((o & mask) << 4) | ((o & ~mask) >> 4); FIXED_unary_bswap_int128_t(&o, res); }


static void __attribute__((__unused__)) FIXED_unary_bsf_int128_t(const uint128_t *op, uint128_t *res){ int i; uint128_t o = *op; if ((uint64_t)o) { *res = __builtin_ctzll(o); return; } else if (o >> 64) { *res = __builtin_ctzll(o >> 64) + 64; return; } else { *res = -1; return; } for (i = 0; i < (int)sizeof(int128_t) * 8; i++) if (o & ((uint128_t)1 << i)) { *res = (uint128_t)i; return; } *res = (uint128_t)-1; } static void __attribute__((__unused__)) FIXED_unary_bsr_int128_t(const uint128_t *op, uint128_t *res){ int i; uint128_t o = *op; if (o >> 64) { *res = (127 ^ __builtin_clzll((uint64_t)(o >> 64))); return; } else if ((__builtin_expect((int)((uint64_t)o != 0), 1))) { *res = ((unsigned)sizeof(unsigned long long) * 8 - 1) ^ __builtin_clzll((uint64_t)o); return; } else { *res = -1; return; } for (i = (int)sizeof(int128_t) * 8 - 1; i >= 0; i--) if (o & ((uint128_t)1 << i)) { *res = (uint128_t)i; return; } *res = (uint128_t)-1; }
static void __attribute__((__unused__)) FIXED_unary_popcnt_int128_t(const uint128_t *op, uint128_t *res){ unsigned r; uint128_t o = *op; *res = (unsigned)__builtin_popcountll((uint64_t)o) + (unsigned)__builtin_popcountll((uint64_t)(o >> 64)); return; r = 0; while (o) o &= o - 1, r++; *res = (uint128_t)r; }
# 73 "./for-fix.inc" 2
# 707 "./arithm-b.h" 2
# 29 "ipret.c" 2
# 1 "./arithm-i.h" 1
# 690 "./arithm-i.h"
# 1 "./for-int.inc" 1
# 24 "./for-int.inc"
# 1 "./arithm-i.inc" 1
# 28 "./arithm-i.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_add_int8_t(const int8_t *op1, const int8_t *op2, int8_t *res){ int8_t o1; __asm__ volatile (".if 0 \n .endif" : "=r"(o1) : "0"(*op1)); __asm__ goto ("							\n		""add" "b""	%1, %0				\n		jo			%l[overflow]			\n		mov""b""		%0, %2				\n	" : : "q"(o1), "q"(*op2), "m"(*res) : "memory", "cc" : overflow); return 1; overflow: return 0; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_subtract_int8_t(const int8_t *op1, const int8_t *op2, int8_t *res){ int8_t o1; __asm__ volatile (".if 0 \n .endif" : "=r"(o1) : "0"(*op1)); __asm__ goto ("							\n		""sub" "b""	%1, %0				\n		jo			%l[overflow]			\n		mov""b""		%0, %2				\n	" : : "q"(o1), "q"(*op2), "m"(*res) : "memory", "cc" : overflow); return 1; overflow: return 0; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_multiply_int8_t(const int8_t *op1, const int8_t *op2, int8_t *res){ int8_t r; if ((__builtin_expect((int)(__builtin_mul_overflow(*op1, *op2, &r)), 0))) return 0; *res = r; return 1; }
# 104 "./arithm-i.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_divide_int8_t(const int8_t *op1, const int8_t *op2, int8_t *res){ int8_t o1 = *op1, o2 = *op2; if ((__builtin_expect((int)(!o2), 0))) return 0; if ((__builtin_expect((int)(o2 == -1), 0)) && (__builtin_expect((int)(o1 == ((int8_t)(-((int8_t)1 << (8 * sizeof(int8_t) - 2)) * 2))), 0))) return 0; if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) *res = o1 / o2; else FIXED_binary_divide_int8_t(((const uint8_t *)(void *)(op1)), ((const uint8_t *)(void *)(op2)), ((uint8_t *)(void *)(res))); return 1; }



static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_modulo_int8_t(const int8_t *op1, const int8_t *op2, int8_t *res){ int8_t o1 = *op1, o2 = *op2; if ((__builtin_expect((int)(!o2), 0))) return 0; if ((__builtin_expect((int)(o2 == -1), 0)) && (__builtin_expect((int)(o1 == ((int8_t)(-((int8_t)1 << (8 * sizeof(int8_t) - 2)) * 2))), 0))) return 0; if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) *res = o1 % o2; else FIXED_binary_modulo_int8_t(((const uint8_t *)(void *)(op1)), ((const uint8_t *)(void *)(op2)), ((uint8_t *)(void *)(res))); return 1; }




static _Bool __attribute__((__unused__)) INT_binary_power_int8_t(const int8_t *op1, const int8_t *op2, int8_t *res){ int8_t r = 1; int8_t o1 = *op1; int8_t o2 = *op2; if ((__builtin_expect((int)(o2 < 0), 0))) return 0; while (1) { if (o2 & 1) { if ((__builtin_expect((int)(!INT_binary_multiply_int8_t(&r, &o1, &r)), 0))) return 0; } o2 >>= 1; if (!o2) break; if ((__builtin_expect((int)(!INT_binary_multiply_int8_t(&o1, &o1, &o1)), 0))) return 0; } *res = r; return 1; }

static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_shl_int8_t(const int8_t *op1, const int8_t *op2, int8_t *res){ int8_t o1 = *op1, o2 = *op2; if ((__builtin_expect((int)((uint8_t)o2 >= (int)sizeof(int8_t) * 8), 0))) return 0; if (sizeof(int8_t) <= sizeof(int64_t) / 2) { int64_t r = (int64_t)o1 << o2; if ((__builtin_expect((int)(r != (int8_t)r), 0))) return 0; *res = (int8_t)r; return 1; } else { int8_t r = (uint8_t)o1 << o2; if (!((~(intmax_t)0x1234U >> 1) == ~(intmax_t)0x91aU)) if ((__builtin_expect((int)(r < 0), 0))) return 0; if ((__builtin_expect((int)(r >> o2 != o1), 0))) return 0; *res = r; return 1; } }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_shr_int8_t(const int8_t *op1, const int8_t *op2, int8_t *res){ int8_t o1 = *op1, o2 = *op2; int8_t r; if ((__builtin_expect((int)((uint8_t)o2 >= (int)sizeof(int8_t) * 8), 0))) return 0; if (!((~(intmax_t)0x1234U >> 1) == ~(intmax_t)0x91aU)) if ((__builtin_expect((int)(o1 < 0), 0))) return 0; r = o1 >> o2; *res = r; return 1; }

static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_bts_int8_t(const int8_t *op1, const int8_t *op2, int8_t *res){ if ((__builtin_expect((int)((uint8_t)*op2 >= sizeof(int8_t) * 8 - 1), 0))) { if ((__builtin_expect((int)(*op2 < 0), 0))) return 0; if (0 == 0 && *op1 < 0) { *res = *op1; return 1; } if (0 == 1 && *op1 >= 0) { *res = *op1; return 1; } return 0; } FIXED_binary_bts_int8_t(((uint8_t *)(void *)(op1)), ((const uint8_t *)(void *)(op2)), ((uint8_t *)(void *)(res))); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_btr_int8_t(const int8_t *op1, const int8_t *op2, int8_t *res){ if ((__builtin_expect((int)((uint8_t)*op2 >= sizeof(int8_t) * 8 - 1), 0))) { if ((__builtin_expect((int)(*op2 < 0), 0))) return 0; if (1 == 0 && *op1 < 0) { *res = *op1; return 1; } if (1 == 1 && *op1 >= 0) { *res = *op1; return 1; } return 0; } FIXED_binary_btr_int8_t(((uint8_t *)(void *)(op1)), ((const uint8_t *)(void *)(op2)), ((uint8_t *)(void *)(res))); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_btc_int8_t(const int8_t *op1, const int8_t *op2, int8_t *res){ if ((__builtin_expect((int)((uint8_t)*op2 >= sizeof(int8_t) * 8 - 1), 0))) { if ((__builtin_expect((int)(*op2 < 0), 0))) return 0; if (2 == 0 && *op1 < 0) { *res = *op1; return 1; } if (2 == 1 && *op1 >= 0) { *res = *op1; return 1; } return 0; } FIXED_binary_btc_int8_t(((uint8_t *)(void *)(op1)), ((const uint8_t *)(void *)(op2)), ((uint8_t *)(void *)(res))); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_bt_int8_t(const int8_t *op1, const int8_t *op2, ajla_flat_option_t *res){ int8_t o1 = *((int8_t *)(void *)(op1)); int8_t o2 = *((int8_t *)(void *)(op2)); if ((__builtin_expect((int)((uint8_t)o2 >= sizeof(int8_t) * 8), 0))) { if ((__builtin_expect((int)(o2 < 0), 0))) return 0; *res = o1 < 0; } else { *res = (ajla_flat_option_t)(((uint8_t)o1 >> o2) & 1); } return 1; }

static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_not_int8_t(const int8_t *op, int8_t *res){ *res = ~(uint8_t)*op; return 1; }




static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_neg_int8_t(const int8_t *op, int8_t *res){ int8_t o; __asm__ volatile (".if 0 \n .endif" : "=r"(o) : "0"(*op)); __asm__ goto ("							\n		neg""b""		%0				\n		jo			%l[overflow]			\n		mov""b""		%0, %1				\n	" : : "q"(o), "m"(*res) : "memory", "cc" : overflow); return 1; overflow: return 0; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_inc_int8_t(const int8_t *op, int8_t *res){ int8_t o; __asm__ volatile (".if 0 \n .endif" : "=r"(o) : "0"(*op)); __asm__ goto ("							\n		""inc""""b""		%0				\n		jo			%l[overflow]			\n		mov""b""		%0, %1				\n	" : : "q"(o), "m"(*res) : "memory", "cc" : overflow); return 1; overflow: return 0; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_dec_int8_t(const int8_t *op, int8_t *res){ int8_t o; __asm__ volatile (".if 0 \n .endif" : "=r"(o) : "0"(*op)); __asm__ goto ("							\n		""dec""""b""		%0				\n		jo			%l[overflow]			\n		mov""b""		%0, %1				\n	" : : "q"(o), "m"(*res) : "memory", "cc" : overflow); return 1; overflow: return 0; }
# 185 "./arithm-i.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_bsf_int8_t(const int8_t *op, int8_t *res){ if (!(0) && (__builtin_expect((int)(!*op), 0))) return 0; if ((0) && (__builtin_expect((int)(*op <= 0), 0))) return 0; if (!(0)) FIXED_unary_bsf_int8_t(((const uint8_t *)(void *)(op)), ((uint8_t *)(void *)(res))); else FIXED_unary_bsr_int8_t(((const uint8_t *)(void *)(op)), ((uint8_t *)(void *)(res))); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_bsr_int8_t(const int8_t *op, int8_t *res){ if (!(1) && (__builtin_expect((int)(!*op), 0))) return 0; if ((1) && (__builtin_expect((int)(*op <= 0), 0))) return 0; if (!(1)) FIXED_unary_bsf_int8_t(((const uint8_t *)(void *)(op)), ((uint8_t *)(void *)(res))); else FIXED_unary_bsr_int8_t(((const uint8_t *)(void *)(op)), ((uint8_t *)(void *)(res))); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_popcnt_int8_t(const int8_t *op, int8_t *res){ if ((__builtin_expect((int)(*op < 0), 0))) return 0; FIXED_unary_popcnt_int8_t(((const uint8_t *)(void *)(op)), ((uint8_t *)(void *)(res))); return 1; }

static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_popcnt_alt1_int8_t(const int8_t *op, int8_t *res){ if ((__builtin_expect((int)(*op < 0), 0))) return 0; FIXED_unary_popcnt_alt1_int8_t(((const uint8_t *)(void *)(op)), ((uint8_t *)(void *)(res))); return 1; }
# 25 "./for-int.inc" 2
# 36 "./for-int.inc"
# 1 "./arithm-i.inc" 1
# 32 "./arithm-i.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_add_int16_t(const int16_t *op1, const int16_t *op2, int16_t *res){ int16_t o1; __asm__ volatile (".if 0 \n .endif" : "=r"(o1) : "0"(*op1)); __asm__ goto ("							\n		""add" "w""	%1, %0				\n		jo			%l[overflow]			\n		mov""w""		%0, %2				\n	" : : "r"(o1), "r"(*op2), "m"(*res) : "memory", "cc" : overflow); return 1; overflow: return 0; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_subtract_int16_t(const int16_t *op1, const int16_t *op2, int16_t *res){ int16_t o1; __asm__ volatile (".if 0 \n .endif" : "=r"(o1) : "0"(*op1)); __asm__ goto ("							\n		""sub" "w""	%1, %0				\n		jo			%l[overflow]			\n		mov""w""		%0, %2				\n	" : : "r"(o1), "r"(*op2), "m"(*res) : "memory", "cc" : overflow); return 1; overflow: return 0; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_multiply_int16_t(const int16_t *op1, const int16_t *op2, int16_t *res){ int16_t o1; __asm__ volatile (".if 0 \n .endif" : "=r"(o1) : "0"(*op1)); __asm__ goto ("							\n		""imul" "w""	%1, %0				\n		jo			%l[overflow]			\n		mov""w""		%0, %2				\n	" : : "r"(o1), "r"(*op2), "m"(*res) : "memory", "cc" : overflow); return 1; overflow: return 0; }
# 104 "./arithm-i.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_divide_int16_t(const int16_t *op1, const int16_t *op2, int16_t *res){ int16_t o1 = *op1, o2 = *op2; if ((__builtin_expect((int)(!o2), 0))) return 0; if ((__builtin_expect((int)(o2 == -1), 0)) && (__builtin_expect((int)(o1 == ((int16_t)(-((int16_t)1 << (8 * sizeof(int16_t) - 2)) * 2))), 0))) return 0; if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) *res = o1 / o2; else FIXED_binary_divide_int16_t(((const uint16_t *)(void *)(op1)), ((const uint16_t *)(void *)(op2)), ((uint16_t *)(void *)(res))); return 1; }



static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_modulo_int16_t(const int16_t *op1, const int16_t *op2, int16_t *res){ int16_t o1 = *op1, o2 = *op2; if ((__builtin_expect((int)(!o2), 0))) return 0; if ((__builtin_expect((int)(o2 == -1), 0)) && (__builtin_expect((int)(o1 == ((int16_t)(-((int16_t)1 << (8 * sizeof(int16_t) - 2)) * 2))), 0))) return 0; if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) *res = o1 % o2; else FIXED_binary_modulo_int16_t(((const uint16_t *)(void *)(op1)), ((const uint16_t *)(void *)(op2)), ((uint16_t *)(void *)(res))); return 1; }




static _Bool __attribute__((__unused__)) INT_binary_power_int16_t(const int16_t *op1, const int16_t *op2, int16_t *res){ int16_t r = 1; int16_t o1 = *op1; int16_t o2 = *op2; if ((__builtin_expect((int)(o2 < 0), 0))) return 0; while (1) { if (o2 & 1) { if ((__builtin_expect((int)(!INT_binary_multiply_int16_t(&r, &o1, &r)), 0))) return 0; } o2 >>= 1; if (!o2) break; if ((__builtin_expect((int)(!INT_binary_multiply_int16_t(&o1, &o1, &o1)), 0))) return 0; } *res = r; return 1; }

static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_shl_int16_t(const int16_t *op1, const int16_t *op2, int16_t *res){ int16_t o1 = *op1, o2 = *op2; if ((__builtin_expect((int)((uint16_t)o2 >= (int)sizeof(int16_t) * 8), 0))) return 0; if (sizeof(int16_t) <= sizeof(int64_t) / 2) { int64_t r = (int64_t)o1 << o2; if ((__builtin_expect((int)(r != (int16_t)r), 0))) return 0; *res = (int16_t)r; return 1; } else { int16_t r = (uint16_t)o1 << o2; if (!((~(intmax_t)0x1234U >> 1) == ~(intmax_t)0x91aU)) if ((__builtin_expect((int)(r < 0), 0))) return 0; if ((__builtin_expect((int)(r >> o2 != o1), 0))) return 0; *res = r; return 1; } }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_shr_int16_t(const int16_t *op1, const int16_t *op2, int16_t *res){ int16_t o1 = *op1, o2 = *op2; int16_t r; if ((__builtin_expect((int)((uint16_t)o2 >= (int)sizeof(int16_t) * 8), 0))) return 0; if (!((~(intmax_t)0x1234U >> 1) == ~(intmax_t)0x91aU)) if ((__builtin_expect((int)(o1 < 0), 0))) return 0; r = o1 >> o2; *res = r; return 1; }

static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_bts_int16_t(const int16_t *op1, const int16_t *op2, int16_t *res){ if ((__builtin_expect((int)((uint16_t)*op2 >= sizeof(int16_t) * 8 - 1), 0))) { if ((__builtin_expect((int)(*op2 < 0), 0))) return 0; if (0 == 0 && *op1 < 0) { *res = *op1; return 1; } if (0 == 1 && *op1 >= 0) { *res = *op1; return 1; } return 0; } FIXED_binary_bts_int16_t(((uint16_t *)(void *)(op1)), ((const uint16_t *)(void *)(op2)), ((uint16_t *)(void *)(res))); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_btr_int16_t(const int16_t *op1, const int16_t *op2, int16_t *res){ if ((__builtin_expect((int)((uint16_t)*op2 >= sizeof(int16_t) * 8 - 1), 0))) { if ((__builtin_expect((int)(*op2 < 0), 0))) return 0; if (1 == 0 && *op1 < 0) { *res = *op1; return 1; } if (1 == 1 && *op1 >= 0) { *res = *op1; return 1; } return 0; } FIXED_binary_btr_int16_t(((uint16_t *)(void *)(op1)), ((const uint16_t *)(void *)(op2)), ((uint16_t *)(void *)(res))); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_btc_int16_t(const int16_t *op1, const int16_t *op2, int16_t *res){ if ((__builtin_expect((int)((uint16_t)*op2 >= sizeof(int16_t) * 8 - 1), 0))) { if ((__builtin_expect((int)(*op2 < 0), 0))) return 0; if (2 == 0 && *op1 < 0) { *res = *op1; return 1; } if (2 == 1 && *op1 >= 0) { *res = *op1; return 1; } return 0; } FIXED_binary_btc_int16_t(((uint16_t *)(void *)(op1)), ((const uint16_t *)(void *)(op2)), ((uint16_t *)(void *)(res))); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_bt_int16_t(const int16_t *op1, const int16_t *op2, ajla_flat_option_t *res){ int16_t o1 = *((int16_t *)(void *)(op1)); int16_t o2 = *((int16_t *)(void *)(op2)); if ((__builtin_expect((int)((uint16_t)o2 >= sizeof(int16_t) * 8), 0))) { if ((__builtin_expect((int)(o2 < 0), 0))) return 0; *res = o1 < 0; } else { *res = (ajla_flat_option_t)(((uint16_t)o1 >> o2) & 1); } return 1; }

static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_not_int16_t(const int16_t *op, int16_t *res){ *res = ~(uint16_t)*op; return 1; }
# 132 "./arithm-i.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_neg_int16_t(const int16_t *op, int16_t *res){ int16_t o; __asm__ volatile (".if 0 \n .endif" : "=r"(o) : "0"(*op)); __asm__ goto ("							\n		neg""w""		%0				\n		jo			%l[overflow]			\n		mov""w""		%0, %1				\n	" : : "r"(o), "m"(*res) : "memory", "cc" : overflow); return 1; overflow: return 0; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_inc_int16_t(const int16_t *op, int16_t *res){ int16_t o; __asm__ volatile (".if 0 \n .endif" : "=r"(o) : "0"(*op)); __asm__ goto ("							\n		""inc""""w""		%0				\n		jo			%l[overflow]			\n		mov""w""		%0, %1				\n	" : : "r"(o), "m"(*res) : "memory", "cc" : overflow); return 1; overflow: return 0; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_dec_int16_t(const int16_t *op, int16_t *res){ int16_t o; __asm__ volatile (".if 0 \n .endif" : "=r"(o) : "0"(*op)); __asm__ goto ("							\n		""dec""""w""		%0				\n		jo			%l[overflow]			\n		mov""w""		%0, %1				\n	" : : "r"(o), "m"(*res) : "memory", "cc" : overflow); return 1; overflow: return 0; }
# 185 "./arithm-i.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_bsf_int16_t(const int16_t *op, int16_t *res){ if (!(0) && (__builtin_expect((int)(!*op), 0))) return 0; if ((0) && (__builtin_expect((int)(*op <= 0), 0))) return 0; if (!(0)) FIXED_unary_bsf_int16_t(((const uint16_t *)(void *)(op)), ((uint16_t *)(void *)(res))); else FIXED_unary_bsr_int16_t(((const uint16_t *)(void *)(op)), ((uint16_t *)(void *)(res))); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_bsr_int16_t(const int16_t *op, int16_t *res){ if (!(1) && (__builtin_expect((int)(!*op), 0))) return 0; if ((1) && (__builtin_expect((int)(*op <= 0), 0))) return 0; if (!(1)) FIXED_unary_bsf_int16_t(((const uint16_t *)(void *)(op)), ((uint16_t *)(void *)(res))); else FIXED_unary_bsr_int16_t(((const uint16_t *)(void *)(op)), ((uint16_t *)(void *)(res))); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_popcnt_int16_t(const int16_t *op, int16_t *res){ if ((__builtin_expect((int)(*op < 0), 0))) return 0; FIXED_unary_popcnt_int16_t(((const uint16_t *)(void *)(op)), ((uint16_t *)(void *)(res))); return 1; }

static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_popcnt_alt1_int16_t(const int16_t *op, int16_t *res){ if ((__builtin_expect((int)(*op < 0), 0))) return 0; FIXED_unary_popcnt_alt1_int16_t(((const uint16_t *)(void *)(op)), ((uint16_t *)(void *)(res))); return 1; }
# 37 "./for-int.inc" 2
# 48 "./for-int.inc"
# 1 "./arithm-i.inc" 1
# 36 "./arithm-i.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_add_int32_t(const int32_t *op1, const int32_t *op2, int32_t *res){ int32_t o1; __asm__ volatile (".if 0 \n .endif" : "=r"(o1) : "0"(*op1)); __asm__ goto ("							\n		""add" "l""	%1, %0				\n		jo			%l[overflow]			\n		mov""l""		%0, %2				\n	" : : "r"(o1), "r"(*op2), "m"(*res) : "memory", "cc" : overflow); return 1; overflow: return 0; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_subtract_int32_t(const int32_t *op1, const int32_t *op2, int32_t *res){ int32_t o1; __asm__ volatile (".if 0 \n .endif" : "=r"(o1) : "0"(*op1)); __asm__ goto ("							\n		""sub" "l""	%1, %0				\n		jo			%l[overflow]			\n		mov""l""		%0, %2				\n	" : : "r"(o1), "r"(*op2), "m"(*res) : "memory", "cc" : overflow); return 1; overflow: return 0; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_multiply_int32_t(const int32_t *op1, const int32_t *op2, int32_t *res){ int32_t o1; __asm__ volatile (".if 0 \n .endif" : "=r"(o1) : "0"(*op1)); __asm__ goto ("							\n		""imul" "l""	%1, %0				\n		jo			%l[overflow]			\n		mov""l""		%0, %2				\n	" : : "r"(o1), "r"(*op2), "m"(*res) : "memory", "cc" : overflow); return 1; overflow: return 0; }
# 104 "./arithm-i.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_divide_int32_t(const int32_t *op1, const int32_t *op2, int32_t *res){ int32_t o1 = *op1, o2 = *op2; if ((__builtin_expect((int)(!o2), 0))) return 0; if ((__builtin_expect((int)(o2 == -1), 0)) && (__builtin_expect((int)(o1 == ((int32_t)(-((int32_t)1 << (8 * sizeof(int32_t) - 2)) * 2))), 0))) return 0; if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) *res = o1 / o2; else FIXED_binary_divide_int32_t(((const uint32_t *)(void *)(op1)), ((const uint32_t *)(void *)(op2)), ((uint32_t *)(void *)(res))); return 1; }



static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_modulo_int32_t(const int32_t *op1, const int32_t *op2, int32_t *res){ int32_t o1 = *op1, o2 = *op2; if ((__builtin_expect((int)(!o2), 0))) return 0; if ((__builtin_expect((int)(o2 == -1), 0)) && (__builtin_expect((int)(o1 == ((int32_t)(-((int32_t)1 << (8 * sizeof(int32_t) - 2)) * 2))), 0))) return 0; if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) *res = o1 % o2; else FIXED_binary_modulo_int32_t(((const uint32_t *)(void *)(op1)), ((const uint32_t *)(void *)(op2)), ((uint32_t *)(void *)(res))); return 1; }




static _Bool __attribute__((__unused__)) INT_binary_power_int32_t(const int32_t *op1, const int32_t *op2, int32_t *res){ int32_t r = 1; int32_t o1 = *op1; int32_t o2 = *op2; if ((__builtin_expect((int)(o2 < 0), 0))) return 0; while (1) { if (o2 & 1) { if ((__builtin_expect((int)(!INT_binary_multiply_int32_t(&r, &o1, &r)), 0))) return 0; } o2 >>= 1; if (!o2) break; if ((__builtin_expect((int)(!INT_binary_multiply_int32_t(&o1, &o1, &o1)), 0))) return 0; } *res = r; return 1; }

static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_shl_int32_t(const int32_t *op1, const int32_t *op2, int32_t *res){ int32_t o1 = *op1, o2 = *op2; if ((__builtin_expect((int)((uint32_t)o2 >= (int)sizeof(int32_t) * 8), 0))) return 0; if (sizeof(int32_t) <= sizeof(int64_t) / 2) { int64_t r = (int64_t)o1 << o2; if ((__builtin_expect((int)(r != (int32_t)r), 0))) return 0; *res = (int32_t)r; return 1; } else { int32_t r = (uint32_t)o1 << o2; if (!((~(intmax_t)0x1234U >> 1) == ~(intmax_t)0x91aU)) if ((__builtin_expect((int)(r < 0), 0))) return 0; if ((__builtin_expect((int)(r >> o2 != o1), 0))) return 0; *res = r; return 1; } }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_shr_int32_t(const int32_t *op1, const int32_t *op2, int32_t *res){ int32_t o1 = *op1, o2 = *op2; int32_t r; if ((__builtin_expect((int)((uint32_t)o2 >= (int)sizeof(int32_t) * 8), 0))) return 0; if (!((~(intmax_t)0x1234U >> 1) == ~(intmax_t)0x91aU)) if ((__builtin_expect((int)(o1 < 0), 0))) return 0; r = o1 >> o2; *res = r; return 1; }

static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_bts_int32_t(const int32_t *op1, const int32_t *op2, int32_t *res){ if ((__builtin_expect((int)((uint32_t)*op2 >= sizeof(int32_t) * 8 - 1), 0))) { if ((__builtin_expect((int)(*op2 < 0), 0))) return 0; if (0 == 0 && *op1 < 0) { *res = *op1; return 1; } if (0 == 1 && *op1 >= 0) { *res = *op1; return 1; } return 0; } FIXED_binary_bts_int32_t(((uint32_t *)(void *)(op1)), ((const uint32_t *)(void *)(op2)), ((uint32_t *)(void *)(res))); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_btr_int32_t(const int32_t *op1, const int32_t *op2, int32_t *res){ if ((__builtin_expect((int)((uint32_t)*op2 >= sizeof(int32_t) * 8 - 1), 0))) { if ((__builtin_expect((int)(*op2 < 0), 0))) return 0; if (1 == 0 && *op1 < 0) { *res = *op1; return 1; } if (1 == 1 && *op1 >= 0) { *res = *op1; return 1; } return 0; } FIXED_binary_btr_int32_t(((uint32_t *)(void *)(op1)), ((const uint32_t *)(void *)(op2)), ((uint32_t *)(void *)(res))); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_btc_int32_t(const int32_t *op1, const int32_t *op2, int32_t *res){ if ((__builtin_expect((int)((uint32_t)*op2 >= sizeof(int32_t) * 8 - 1), 0))) { if ((__builtin_expect((int)(*op2 < 0), 0))) return 0; if (2 == 0 && *op1 < 0) { *res = *op1; return 1; } if (2 == 1 && *op1 >= 0) { *res = *op1; return 1; } return 0; } FIXED_binary_btc_int32_t(((uint32_t *)(void *)(op1)), ((const uint32_t *)(void *)(op2)), ((uint32_t *)(void *)(res))); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_bt_int32_t(const int32_t *op1, const int32_t *op2, ajla_flat_option_t *res){ int32_t o1 = *((int32_t *)(void *)(op1)); int32_t o2 = *((int32_t *)(void *)(op2)); if ((__builtin_expect((int)((uint32_t)o2 >= sizeof(int32_t) * 8), 0))) { if ((__builtin_expect((int)(o2 < 0), 0))) return 0; *res = o1 < 0; } else { *res = (ajla_flat_option_t)(((uint32_t)o1 >> o2) & 1); } return 1; }

static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_not_int32_t(const int32_t *op, int32_t *res){ *res = ~(uint32_t)*op; return 1; }
# 136 "./arithm-i.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_neg_int32_t(const int32_t *op, int32_t *res){ int32_t o; __asm__ volatile (".if 0 \n .endif" : "=r"(o) : "0"(*op)); __asm__ goto ("							\n		neg""l""		%0				\n		jo			%l[overflow]			\n		mov""l""		%0, %1				\n	" : : "r"(o), "m"(*res) : "memory", "cc" : overflow); return 1; overflow: return 0; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_inc_int32_t(const int32_t *op, int32_t *res){ int32_t o; __asm__ volatile (".if 0 \n .endif" : "=r"(o) : "0"(*op)); __asm__ goto ("							\n		""inc""""l""		%0				\n		jo			%l[overflow]			\n		mov""l""		%0, %1				\n	" : : "r"(o), "m"(*res) : "memory", "cc" : overflow); return 1; overflow: return 0; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_dec_int32_t(const int32_t *op, int32_t *res){ int32_t o; __asm__ volatile (".if 0 \n .endif" : "=r"(o) : "0"(*op)); __asm__ goto ("							\n		""dec""""l""		%0				\n		jo			%l[overflow]			\n		mov""l""		%0, %1				\n	" : : "r"(o), "m"(*res) : "memory", "cc" : overflow); return 1; overflow: return 0; }
# 185 "./arithm-i.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_bsf_int32_t(const int32_t *op, int32_t *res){ if (!(0) && (__builtin_expect((int)(!*op), 0))) return 0; if ((0) && (__builtin_expect((int)(*op <= 0), 0))) return 0; if (!(0)) FIXED_unary_bsf_int32_t(((const uint32_t *)(void *)(op)), ((uint32_t *)(void *)(res))); else FIXED_unary_bsr_int32_t(((const uint32_t *)(void *)(op)), ((uint32_t *)(void *)(res))); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_bsr_int32_t(const int32_t *op, int32_t *res){ if (!(1) && (__builtin_expect((int)(!*op), 0))) return 0; if ((1) && (__builtin_expect((int)(*op <= 0), 0))) return 0; if (!(1)) FIXED_unary_bsf_int32_t(((const uint32_t *)(void *)(op)), ((uint32_t *)(void *)(res))); else FIXED_unary_bsr_int32_t(((const uint32_t *)(void *)(op)), ((uint32_t *)(void *)(res))); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_popcnt_int32_t(const int32_t *op, int32_t *res){ if ((__builtin_expect((int)(*op < 0), 0))) return 0; FIXED_unary_popcnt_int32_t(((const uint32_t *)(void *)(op)), ((uint32_t *)(void *)(res))); return 1; }

static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_popcnt_alt1_int32_t(const int32_t *op, int32_t *res){ if ((__builtin_expect((int)(*op < 0), 0))) return 0; FIXED_unary_popcnt_alt1_int32_t(((const uint32_t *)(void *)(op)), ((uint32_t *)(void *)(res))); return 1; }
# 49 "./for-int.inc" 2
# 60 "./for-int.inc"
# 1 "./arithm-i.inc" 1
# 44 "./arithm-i.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_add_int64_t(const int64_t *op1, const int64_t *op2, int64_t *res){ int64_t o1; __asm__ volatile (".if 0 \n .endif" : "=r"(o1) : "0"(*op1)); __asm__ goto ("							\n		""add" "q""	%1, %0				\n		jo			%l[overflow]			\n		mov""q""		%0, %2				\n	" : : "r"(o1), "r"(*op2), "m"(*res) : "memory", "cc" : overflow); return 1; overflow: return 0; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_subtract_int64_t(const int64_t *op1, const int64_t *op2, int64_t *res){ int64_t o1; __asm__ volatile (".if 0 \n .endif" : "=r"(o1) : "0"(*op1)); __asm__ goto ("							\n		""sub" "q""	%1, %0				\n		jo			%l[overflow]			\n		mov""q""		%0, %2				\n	" : : "r"(o1), "r"(*op2), "m"(*res) : "memory", "cc" : overflow); return 1; overflow: return 0; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_multiply_int64_t(const int64_t *op1, const int64_t *op2, int64_t *res){ int64_t o1; __asm__ volatile (".if 0 \n .endif" : "=r"(o1) : "0"(*op1)); __asm__ goto ("							\n		""imul" "q""	%1, %0				\n		jo			%l[overflow]			\n		mov""q""		%0, %2				\n	" : : "r"(o1), "r"(*op2), "m"(*res) : "memory", "cc" : overflow); return 1; overflow: return 0; }
# 104 "./arithm-i.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_divide_int64_t(const int64_t *op1, const int64_t *op2, int64_t *res){ int64_t o1 = *op1, o2 = *op2; if ((__builtin_expect((int)(!o2), 0))) return 0; if ((__builtin_expect((int)(o2 == -1), 0)) && (__builtin_expect((int)(o1 == ((int64_t)(-((int64_t)1 << (8 * sizeof(int64_t) - 2)) * 2))), 0))) return 0; if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) *res = o1 / o2; else FIXED_binary_divide_int64_t(((const uint64_t *)(void *)(op1)), ((const uint64_t *)(void *)(op2)), ((uint64_t *)(void *)(res))); return 1; }



static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_modulo_int64_t(const int64_t *op1, const int64_t *op2, int64_t *res){ int64_t o1 = *op1, o2 = *op2; if ((__builtin_expect((int)(!o2), 0))) return 0; if ((__builtin_expect((int)(o2 == -1), 0)) && (__builtin_expect((int)(o1 == ((int64_t)(-((int64_t)1 << (8 * sizeof(int64_t) - 2)) * 2))), 0))) return 0; if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) *res = o1 % o2; else FIXED_binary_modulo_int64_t(((const uint64_t *)(void *)(op1)), ((const uint64_t *)(void *)(op2)), ((uint64_t *)(void *)(res))); return 1; }




static _Bool __attribute__((__unused__)) INT_binary_power_int64_t(const int64_t *op1, const int64_t *op2, int64_t *res){ int64_t r = 1; int64_t o1 = *op1; int64_t o2 = *op2; if ((__builtin_expect((int)(o2 < 0), 0))) return 0; while (1) { if (o2 & 1) { if ((__builtin_expect((int)(!INT_binary_multiply_int64_t(&r, &o1, &r)), 0))) return 0; } o2 >>= 1; if (!o2) break; if ((__builtin_expect((int)(!INT_binary_multiply_int64_t(&o1, &o1, &o1)), 0))) return 0; } *res = r; return 1; }

static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_shl_int64_t(const int64_t *op1, const int64_t *op2, int64_t *res){ int64_t o1 = *op1, o2 = *op2; if ((__builtin_expect((int)((uint64_t)o2 >= (int)sizeof(int64_t) * 8), 0))) return 0; if (sizeof(int64_t) <= sizeof(int64_t) / 2) { int64_t r = (int64_t)o1 << o2; if ((__builtin_expect((int)(r != (int64_t)r), 0))) return 0; *res = (int64_t)r; return 1; } else { int64_t r = (uint64_t)o1 << o2; if (!((~(intmax_t)0x1234U >> 1) == ~(intmax_t)0x91aU)) if ((__builtin_expect((int)(r < 0), 0))) return 0; if ((__builtin_expect((int)(r >> o2 != o1), 0))) return 0; *res = r; return 1; } }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_shr_int64_t(const int64_t *op1, const int64_t *op2, int64_t *res){ int64_t o1 = *op1, o2 = *op2; int64_t r; if ((__builtin_expect((int)((uint64_t)o2 >= (int)sizeof(int64_t) * 8), 0))) return 0; if (!((~(intmax_t)0x1234U >> 1) == ~(intmax_t)0x91aU)) if ((__builtin_expect((int)(o1 < 0), 0))) return 0; r = o1 >> o2; *res = r; return 1; }

static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_bts_int64_t(const int64_t *op1, const int64_t *op2, int64_t *res){ if ((__builtin_expect((int)((uint64_t)*op2 >= sizeof(int64_t) * 8 - 1), 0))) { if ((__builtin_expect((int)(*op2 < 0), 0))) return 0; if (0 == 0 && *op1 < 0) { *res = *op1; return 1; } if (0 == 1 && *op1 >= 0) { *res = *op1; return 1; } return 0; } FIXED_binary_bts_int64_t(((uint64_t *)(void *)(op1)), ((const uint64_t *)(void *)(op2)), ((uint64_t *)(void *)(res))); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_btr_int64_t(const int64_t *op1, const int64_t *op2, int64_t *res){ if ((__builtin_expect((int)((uint64_t)*op2 >= sizeof(int64_t) * 8 - 1), 0))) { if ((__builtin_expect((int)(*op2 < 0), 0))) return 0; if (1 == 0 && *op1 < 0) { *res = *op1; return 1; } if (1 == 1 && *op1 >= 0) { *res = *op1; return 1; } return 0; } FIXED_binary_btr_int64_t(((uint64_t *)(void *)(op1)), ((const uint64_t *)(void *)(op2)), ((uint64_t *)(void *)(res))); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_btc_int64_t(const int64_t *op1, const int64_t *op2, int64_t *res){ if ((__builtin_expect((int)((uint64_t)*op2 >= sizeof(int64_t) * 8 - 1), 0))) { if ((__builtin_expect((int)(*op2 < 0), 0))) return 0; if (2 == 0 && *op1 < 0) { *res = *op1; return 1; } if (2 == 1 && *op1 >= 0) { *res = *op1; return 1; } return 0; } FIXED_binary_btc_int64_t(((uint64_t *)(void *)(op1)), ((const uint64_t *)(void *)(op2)), ((uint64_t *)(void *)(res))); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_bt_int64_t(const int64_t *op1, const int64_t *op2, ajla_flat_option_t *res){ int64_t o1 = *((int64_t *)(void *)(op1)); int64_t o2 = *((int64_t *)(void *)(op2)); if ((__builtin_expect((int)((uint64_t)o2 >= sizeof(int64_t) * 8), 0))) { if ((__builtin_expect((int)(o2 < 0), 0))) return 0; *res = o1 < 0; } else { *res = (ajla_flat_option_t)(((uint64_t)o1 >> o2) & 1); } return 1; }

static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_not_int64_t(const int64_t *op, int64_t *res){ *res = ~(uint64_t)*op; return 1; }
# 143 "./arithm-i.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_neg_int64_t(const int64_t *op, int64_t *res){ int64_t o; __asm__ volatile (".if 0 \n .endif" : "=r"(o) : "0"(*op)); __asm__ goto ("							\n		neg""q""		%0				\n		jo			%l[overflow]			\n		mov""q""		%0, %1				\n	" : : "r"(o), "m"(*res) : "memory", "cc" : overflow); return 1; overflow: return 0; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_inc_int64_t(const int64_t *op, int64_t *res){ int64_t o; __asm__ volatile (".if 0 \n .endif" : "=r"(o) : "0"(*op)); __asm__ goto ("							\n		""inc""""q""		%0				\n		jo			%l[overflow]			\n		mov""q""		%0, %1				\n	" : : "r"(o), "m"(*res) : "memory", "cc" : overflow); return 1; overflow: return 0; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_dec_int64_t(const int64_t *op, int64_t *res){ int64_t o; __asm__ volatile (".if 0 \n .endif" : "=r"(o) : "0"(*op)); __asm__ goto ("							\n		""dec""""q""		%0				\n		jo			%l[overflow]			\n		mov""q""		%0, %1				\n	" : : "r"(o), "m"(*res) : "memory", "cc" : overflow); return 1; overflow: return 0; }
# 185 "./arithm-i.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_bsf_int64_t(const int64_t *op, int64_t *res){ if (!(0) && (__builtin_expect((int)(!*op), 0))) return 0; if ((0) && (__builtin_expect((int)(*op <= 0), 0))) return 0; if (!(0)) FIXED_unary_bsf_int64_t(((const uint64_t *)(void *)(op)), ((uint64_t *)(void *)(res))); else FIXED_unary_bsr_int64_t(((const uint64_t *)(void *)(op)), ((uint64_t *)(void *)(res))); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_bsr_int64_t(const int64_t *op, int64_t *res){ if (!(1) && (__builtin_expect((int)(!*op), 0))) return 0; if ((1) && (__builtin_expect((int)(*op <= 0), 0))) return 0; if (!(1)) FIXED_unary_bsf_int64_t(((const uint64_t *)(void *)(op)), ((uint64_t *)(void *)(res))); else FIXED_unary_bsr_int64_t(((const uint64_t *)(void *)(op)), ((uint64_t *)(void *)(res))); return 1; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_popcnt_int64_t(const int64_t *op, int64_t *res){ if ((__builtin_expect((int)(*op < 0), 0))) return 0; FIXED_unary_popcnt_int64_t(((const uint64_t *)(void *)(op)), ((uint64_t *)(void *)(res))); return 1; }

static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_popcnt_alt1_int64_t(const int64_t *op, int64_t *res){ if ((__builtin_expect((int)(*op < 0), 0))) return 0; FIXED_unary_popcnt_alt1_int64_t(((const uint64_t *)(void *)(op)), ((uint64_t *)(void *)(res))); return 1; }
# 61 "./for-int.inc" 2
# 72 "./for-int.inc"
# 1 "./arithm-i.inc" 1
# 48 "./arithm-i.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_add_int128_t(const int128_t *op1, const int128_t *op2, int128_t *res){ int128_t o1; __asm__ volatile (".if 0 \n .endif" : "=r"(o1) : "0"(*op1)); __asm__ goto ("							\n		""add" "q""	%1, %%""r""ax			\n		""adc" "q""	%2, %%""r""dx			\n		jo			%l[overflow]			\n		mov""q""		%%""r""ax, %3			\n		mov""q""		%%""r""dx, %4			\n	" : : "A"(o1), "m"(*op2), "m"(*(((char *)(void *)(op2)) + sizeof(int128_t) / 2)), "m"(*res), "m"(*(((char *)(void *)(res)) + sizeof(int128_t) / 2)) : "memory", "cc" : overflow); return 1; overflow: return 0; }
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_binary_subtract_int128_t(const int128_t *op1, const int128_t *op2, int128_t *res){ int128_t o1; __asm__ volatile (".if 0 \n .endif" : "=r"(o1) : "0"(*op1)); __asm__ goto ("							\n		""sub" "q""	%1, %%""r""ax			\n		""sbb" "q""	%2, %%""r""dx			\n		jo			%l[overflow]			\n		mov""q""		%%""r""ax, %3			\n		mov""q""		%%""r""dx, %4			\n	" : : "A"(o1), "m"(*op2), "m"(*(((char *)(void *)(op2)) + sizeof(int128_t) / 2)), "m"(*res), "m"(*(((char *)(void *)(res)) + sizeof(int128_t) / 2)) : "memory", "cc" : overflow); return 1; overflow: return 0; }
static __attribute__((__noinline__)) _Bool __attribute__((__unused__)) INT_binary_multiply_int128_t(const int128_t *op1, const int128_t *op2, int128_t *res){ int128_t r; if ((__builtin_expect((int)(__builtin_mul_overflow(*op1, *op2, &r)), 0))) return 0; *res = r; return 1; }
# 104 "./arithm-i.inc"
static __attribute__((__noinline__)) _Bool __attribute__((__unused__)) INT_binary_divide_int128_t(const int128_t *op1, const int128_t *op2, int128_t *res){ int128_t o1 = *op1, o2 = *op2; if ((__builtin_expect((int)(!o2), 0))) return 0; if ((__builtin_expect((int)(o2 == -1), 0)) && (__builtin_expect((int)(o1 == ((int128_t)(-((int128_t)1 << (8 * sizeof(int128_t) - 2)) * 2))), 0))) return 0; if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) *res = o1 / o2; else FIXED_binary_divide_int128_t(((const uint128_t *)(void *)(op1)), ((const uint128_t *)(void *)(op2)), ((uint128_t *)(void *)(res))); return 1; }



static __attribute__((__noinline__)) _Bool __attribute__((__unused__)) INT_binary_modulo_int128_t(const int128_t *op1, const int128_t *op2, int128_t *res){ int128_t o1 = *op1, o2 = *op2; if ((__builtin_expect((int)(!o2), 0))) return 0; if ((__builtin_expect((int)(o2 == -1), 0)) && (__builtin_expect((int)(o1 == ((int128_t)(-((int128_t)1 << (8 * sizeof(int128_t) - 2)) * 2))), 0))) return 0; if (((intmax_t)9 / -4 == -2 && (intmax_t)-9 / 4 == -2 && (intmax_t)-9 / -4 == 2 && (intmax_t)9 % -4 == 1 && (intmax_t)-9 % 4 == -1 && (intmax_t)-9 % -4 == -1)) *res = o1 % o2; else FIXED_binary_modulo_int128_t(((const uint128_t *)(void *)(op1)), ((const uint128_t *)(void *)(op2)), ((uint128_t *)(void *)(res))); return 1; }




static _Bool __attribute__((__unused__)) INT_binary_power_int128_t(const int128_t *op1, const int128_t *op2, int128_t *res){ int128_t r = 1; int128_t o1 = *op1; int128_t o2 = *op2; if ((__builtin_expect((int)(o2 < 0), 0))) return 0; while (1) { if (o2 & 1) { if ((__builtin_expect((int)(!INT_binary_multiply_int128_t(&r, &o1, &r)), 0))) return 0; } o2 >>= 1; if (!o2) break; if ((__builtin_expect((int)(!INT_binary_multiply_int128_t(&o1, &o1, &o1)), 0))) return 0; } *res = r; return 1; }

static __attribute__((__noinline__)) _Bool __attribute__((__unused__)) INT_binary_shl_int128_t(const int128_t *op1, const int128_t *op2, int128_t *res){ int128_t o1 = *op1, o2 = *op2; if ((__builtin_expect((int)((uint128_t)o2 >= (int)sizeof(int128_t) * 8), 0))) return 0; if (sizeof(int128_t) <= sizeof(int64_t) / 2) { int64_t r = (int64_t)o1 << o2; if ((__builtin_expect((int)(r != (int128_t)r), 0))) return 0; *res = (int128_t)r; return 1; } else { int128_t r = (uint128_t)o1 << o2; if (!((~(intmax_t)0x1234U >> 1) == ~(intmax_t)0x91aU)) if ((__builtin_expect((int)(r < 0), 0))) return 0; if ((__builtin_expect((int)(r >> o2 != o1), 0))) return 0; *res = r; return 1; } }
static __attribute__((__noinline__)) _Bool __attribute__((__unused__)) INT_binary_shr_int128_t(const int128_t *op1, const int128_t *op2, int128_t *res){ int128_t o1 = *op1, o2 = *op2; int128_t r; if ((__builtin_expect((int)((uint128_t)o2 >= (int)sizeof(int128_t) * 8), 0))) return 0; if (!((~(intmax_t)0x1234U >> 1) == ~(intmax_t)0x91aU)) if ((__builtin_expect((int)(o1 < 0), 0))) return 0; r = o1 >> o2; *res = r; return 1; }

static __attribute__((__noinline__)) _Bool __attribute__((__unused__)) INT_binary_bts_int128_t(const int128_t *op1, const int128_t *op2, int128_t *res){ if ((__builtin_expect((int)((uint128_t)*op2 >= sizeof(int128_t) * 8 - 1), 0))) { if ((__builtin_expect((int)(*op2 < 0), 0))) return 0; if (0 == 0 && *op1 < 0) { *res = *op1; return 1; } if (0 == 1 && *op1 >= 0) { *res = *op1; return 1; } return 0; } FIXED_binary_bts_int128_t(((uint128_t *)(void *)(op1)), ((const uint128_t *)(void *)(op2)), ((uint128_t *)(void *)(res))); return 1; }
static __attribute__((__noinline__)) _Bool __attribute__((__unused__)) INT_binary_btr_int128_t(const int128_t *op1, const int128_t *op2, int128_t *res){ if ((__builtin_expect((int)((uint128_t)*op2 >= sizeof(int128_t) * 8 - 1), 0))) { if ((__builtin_expect((int)(*op2 < 0), 0))) return 0; if (1 == 0 && *op1 < 0) { *res = *op1; return 1; } if (1 == 1 && *op1 >= 0) { *res = *op1; return 1; } return 0; } FIXED_binary_btr_int128_t(((uint128_t *)(void *)(op1)), ((const uint128_t *)(void *)(op2)), ((uint128_t *)(void *)(res))); return 1; }
static __attribute__((__noinline__)) _Bool __attribute__((__unused__)) INT_binary_btc_int128_t(const int128_t *op1, const int128_t *op2, int128_t *res){ if ((__builtin_expect((int)((uint128_t)*op2 >= sizeof(int128_t) * 8 - 1), 0))) { if ((__builtin_expect((int)(*op2 < 0), 0))) return 0; if (2 == 0 && *op1 < 0) { *res = *op1; return 1; } if (2 == 1 && *op1 >= 0) { *res = *op1; return 1; } return 0; } FIXED_binary_btc_int128_t(((uint128_t *)(void *)(op1)), ((const uint128_t *)(void *)(op2)), ((uint128_t *)(void *)(res))); return 1; }
static __attribute__((__noinline__)) _Bool __attribute__((__unused__)) INT_binary_bt_int128_t(const int128_t *op1, const int128_t *op2, ajla_flat_option_t *res){ int128_t o1 = *((int128_t *)(void *)(op1)); int128_t o2 = *((int128_t *)(void *)(op2)); if ((__builtin_expect((int)((uint128_t)o2 >= sizeof(int128_t) * 8), 0))) { if ((__builtin_expect((int)(o2 < 0), 0))) return 0; *res = o1 < 0; } else { *res = (ajla_flat_option_t)(((uint128_t)o1 >> o2) & 1); } return 1; }

static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_not_int128_t(const int128_t *op, int128_t *res){ *res = ~(uint128_t)*op; return 1; }
# 147 "./arithm-i.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_neg_int128_t(const int128_t *op, int128_t *res){ int128_t o; __asm__ volatile (".if 0 \n .endif" : "=r"(o) : "0"(*op)); __asm__ goto ("							\n		neg""q""		%%""r""ax			\n		not""q""		%%""r""dx			\n		sbb""q""		$-1, %%""r""dx			\n		jo			%l[overflow]			\n		mov""q""		%%""r""ax, %1			\n		mov""q""		%%""r""dx, %2			\n	" : : "A"(o), "m"(*res), "m"(*(((char *)(void *)(res)) + sizeof(int128_t) / 2)) : "memory", "cc" : overflow); return 1; overflow: return 0; }
static __attribute__((__noinline__)) _Bool __attribute__((__unused__)) INT_unary_inc_int128_t(const int128_t *op, int128_t *res){ int128_t r; if ((__builtin_expect((int)(__builtin_add_overflow(*op, 1, &r)), 0))) return 0; *res = r; return 1; } static __attribute__((__noinline__)) _Bool __attribute__((__unused__)) INT_unary_dec_int128_t(const int128_t *op, int128_t *res){ int128_t r; if ((__builtin_expect((int)(__builtin_sub_overflow(*op, 1, &r)), 0))) return 0; *res = r; return 1; }
# 185 "./arithm-i.inc"
static __attribute__((__noinline__)) _Bool __attribute__((__unused__)) INT_unary_bsf_int128_t(const int128_t *op, int128_t *res){ if (!(0) && (__builtin_expect((int)(!*op), 0))) return 0; if ((0) && (__builtin_expect((int)(*op <= 0), 0))) return 0; if (!(0)) FIXED_unary_bsf_int128_t(((const uint128_t *)(void *)(op)), ((uint128_t *)(void *)(res))); else FIXED_unary_bsr_int128_t(((const uint128_t *)(void *)(op)), ((uint128_t *)(void *)(res))); return 1; }
static __attribute__((__noinline__)) _Bool __attribute__((__unused__)) INT_unary_bsr_int128_t(const int128_t *op, int128_t *res){ if (!(1) && (__builtin_expect((int)(!*op), 0))) return 0; if ((1) && (__builtin_expect((int)(*op <= 0), 0))) return 0; if (!(1)) FIXED_unary_bsf_int128_t(((const uint128_t *)(void *)(op)), ((uint128_t *)(void *)(res))); else FIXED_unary_bsr_int128_t(((const uint128_t *)(void *)(op)), ((uint128_t *)(void *)(res))); return 1; }
static __attribute__((__noinline__)) _Bool __attribute__((__unused__)) INT_unary_popcnt_int128_t(const int128_t *op, int128_t *res){ if ((__builtin_expect((int)(*op < 0), 0))) return 0; FIXED_unary_popcnt_int128_t(((const uint128_t *)(void *)(op)), ((uint128_t *)(void *)(res))); return 1; }

static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) INT_unary_popcnt_alt1_int128_t(const int128_t *op, int128_t *res){ if ((__builtin_expect((int)(*op < 0), 0))) return 0; FIXED_unary_popcnt_alt1_int128_t(((const uint128_t *)(void *)(op)), ((uint128_t *)(void *)(res))); return 1; }
# 73 "./for-int.inc" 2
# 691 "./arithm-i.h" 2
# 30 "ipret.c" 2
# 1 "./arithm-r.h" 1
# 540 "./arithm-r.h"
# 1 "./for-real.inc" 1
# 23 "./for-real.inc"
# 1 "./arithm-r.inc" 1
# 32 "./arithm-r.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_add_alt1_real16_t(const real16_t *op1, const real16_t *op2, real16_t *res){ __asm__ ("							\n		vpinsrw			$0, %1, %%xmm7, %%xmm0		\n		vpinsrw			$0, %2, %%xmm7, %%xmm1		\n		vcvtph2ps		%%xmm0, %%xmm0			\n		vcvtph2ps		%%xmm1, %%xmm1			\n		v""add""ss		%%xmm1, %%xmm0, %%xmm0		\n		vcvtps2ph		$4, %%xmm0, %%xmm0		\n		vpextrw			$0, %%xmm0, %0			\n	" : "=m"(*res) : "m"(*op1), "m"(*op2) : "xmm0" , "xmm1"); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_subtract_alt1_real16_t(const real16_t *op1, const real16_t *op2, real16_t *res){ __asm__ ("							\n		vpinsrw			$0, %1, %%xmm7, %%xmm0		\n		vpinsrw			$0, %2, %%xmm7, %%xmm1		\n		vcvtph2ps		%%xmm0, %%xmm0			\n		vcvtph2ps		%%xmm1, %%xmm1			\n		v""sub""ss		%%xmm1, %%xmm0, %%xmm0		\n		vcvtps2ph		$4, %%xmm0, %%xmm0		\n		vpextrw			$0, %%xmm0, %0			\n	" : "=m"(*res) : "m"(*op1), "m"(*op2) : "xmm0" , "xmm1"); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_multiply_alt1_real16_t(const real16_t *op1, const real16_t *op2, real16_t *res){ __asm__ ("							\n		vpinsrw			$0, %1, %%xmm7, %%xmm0		\n		vpinsrw			$0, %2, %%xmm7, %%xmm1		\n		vcvtph2ps		%%xmm0, %%xmm0			\n		vcvtph2ps		%%xmm1, %%xmm1			\n		v""mul""ss		%%xmm1, %%xmm0, %%xmm0		\n		vcvtps2ph		$4, %%xmm0, %%xmm0		\n		vpextrw			$0, %%xmm0, %0			\n	" : "=m"(*res) : "m"(*op1), "m"(*op2) : "xmm0" , "xmm1"); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_divide_alt1_real16_t(const real16_t *op1, const real16_t *op2, real16_t *res){ __asm__ ("							\n		vpinsrw			$0, %1, %%xmm7, %%xmm0		\n		vpinsrw			$0, %2, %%xmm7, %%xmm1		\n		vcvtph2ps		%%xmm0, %%xmm0			\n		vcvtph2ps		%%xmm1, %%xmm1			\n		v""div""ss		%%xmm1, %%xmm0, %%xmm0		\n		vcvtps2ph		$4, %%xmm0, %%xmm0		\n		vpextrw			$0, %%xmm0, %0			\n	" : "=m"(*res) : "m"(*op1), "m"(*op2) : "xmm0" , "xmm1"); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_equal_alt1_real16_t(const real16_t *op1, const real16_t *op2, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ goto ("							\n		vpinsrw			$0, %1, %%xmm7, %%xmm0		\n		vpinsrw			$0, %2, %%xmm7, %%xmm1		\n		vcvtph2ps		%%xmm0, %%xmm0			\n		vcvtph2ps		%%xmm1, %%xmm1			\n		vucomiss		%%xmm1, %%xmm0			\n		jp			%l[unordered]			\n		""sete""		%0				\n	" : : "m"(*res), "m"(*op1), "m"(*op2) : "memory", "cc" , "xmm0" , "xmm1" : unordered); return 1; unordered: return 0; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_not_equal_alt1_real16_t(const real16_t *op1, const real16_t *op2, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ goto ("							\n		vpinsrw			$0, %1, %%xmm7, %%xmm0		\n		vpinsrw			$0, %2, %%xmm7, %%xmm1		\n		vcvtph2ps		%%xmm0, %%xmm0			\n		vcvtph2ps		%%xmm1, %%xmm1			\n		vucomiss		%%xmm1, %%xmm0			\n		jp			%l[unordered]			\n		""setne""		%0				\n	" : : "m"(*res), "m"(*op1), "m"(*op2) : "memory", "cc" , "xmm0" , "xmm1" : unordered); return 1; unordered: return 0; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_less_alt1_real16_t(const real16_t *op1, const real16_t *op2, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ goto ("							\n		vpinsrw			$0, %1, %%xmm7, %%xmm0		\n		vpinsrw			$0, %2, %%xmm7, %%xmm1		\n		vcvtph2ps		%%xmm0, %%xmm0			\n		vcvtph2ps		%%xmm1, %%xmm1			\n		vucomiss		%%xmm1, %%xmm0			\n		jp			%l[unordered]			\n		""setb""		%0				\n	" : : "m"(*res), "m"(*op1), "m"(*op2) : "memory", "cc" , "xmm0" , "xmm1" : unordered); return 1; unordered: return 0; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_less_equal_alt1_real16_t(const real16_t *op1, const real16_t *op2, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ goto ("							\n		vpinsrw			$0, %1, %%xmm7, %%xmm0		\n		vpinsrw			$0, %2, %%xmm7, %%xmm1		\n		vcvtph2ps		%%xmm0, %%xmm0			\n		vcvtph2ps		%%xmm1, %%xmm1			\n		vucomiss		%%xmm1, %%xmm0			\n		jp			%l[unordered]			\n		""setbe""		%0				\n	" : : "m"(*res), "m"(*op1), "m"(*op2) : "memory", "cc" , "xmm0" , "xmm1" : unordered); return 1; unordered: return 0; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_unary_to_int_alt1_real16_t(const real16_t *op1, int64_t *res){ int64_t r; __asm__ ("							\n		vpinsrw			$0, %1, %%xmm7, %%xmm0		\n		vcvtph2ps		%%xmm0, %%xmm0			\n		vcvttss2si		%%xmm0, %0			\n	" : "=r"(r) : "m"(*op1) : "xmm0"); if ((__builtin_expect((int)(r == ((int64_t)(-((int64_t)1 << (8 * sizeof(int64_t) - 2)) * 2))), 0))) return 0; *res = r; return 1; } static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) REAL_unary_from_int_alt1_real16_t(const int64_t *op1, real16_t *res){ __asm__ ("							\n		vcvtsi2ss""q""		%1, %%xmm7, %%xmm0		\n		vcvtps2ph		$4, %%xmm0, %%xmm0		\n		vpextrw			$0, %%xmm0, %0			\n	" : "=m"(*res) : "rm"(*op1) : "xmm0"); }
# 24 "./for-real.inc" 2
# 33 "./for-real.inc"
# 1 "./arithm-r.inc" 1
# 37 "./arithm-r.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_add_alt1_real32_t(const real32_t *op1, const real32_t *op2, real32_t *res){ __asm__ ("							\n		""""movs""s""		%1, %%xmm0			\n		""""""add""s""s""	%2, ""%%xmm0""			\n		""""movs""s""		%%xmm0, %0			\n	" : "=m"(*res) : "m"(*op1), "m"(*op2) : "xmm0"); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_subtract_alt1_real32_t(const real32_t *op1, const real32_t *op2, real32_t *res){ __asm__ ("							\n		""""movs""s""		%1, %%xmm0			\n		""""""sub""s""s""	%2, ""%%xmm0""			\n		""""movs""s""		%%xmm0, %0			\n	" : "=m"(*res) : "m"(*op1), "m"(*op2) : "xmm0"); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_multiply_alt1_real32_t(const real32_t *op1, const real32_t *op2, real32_t *res){ __asm__ ("							\n		""""movs""s""		%1, %%xmm0			\n		""""""mul""s""s""	%2, ""%%xmm0""			\n		""""movs""s""		%%xmm0, %0			\n	" : "=m"(*res) : "m"(*op1), "m"(*op2) : "xmm0"); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_divide_alt1_real32_t(const real32_t *op1, const real32_t *op2, real32_t *res){ __asm__ ("							\n		""""movs""s""		%1, %%xmm0			\n		""""""div""s""s""	%2, ""%%xmm0""			\n		""""movs""s""		%%xmm0, %0			\n	" : "=m"(*res) : "m"(*op1), "m"(*op2) : "xmm0"); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_equal_alt1_real32_t(const real32_t *op1, const real32_t *op2, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ goto ("							\n		""""movs""s""		%1, %%xmm0			\n		""""ucomis""s""		%2, %%xmm0			\n		jp			%l[unordered]			\n		""sete""		%0				\n	" : : "m"(*res), "m"(*op1), "m"(*op2) : "memory", "cc" , "xmm0" : unordered); return 1; unordered: return 0; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_not_equal_alt1_real32_t(const real32_t *op1, const real32_t *op2, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ goto ("							\n		""""movs""s""		%1, %%xmm0			\n		""""ucomis""s""		%2, %%xmm0			\n		jp			%l[unordered]			\n		""setne""		%0				\n	" : : "m"(*res), "m"(*op1), "m"(*op2) : "memory", "cc" , "xmm0" : unordered); return 1; unordered: return 0; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_less_alt1_real32_t(const real32_t *op1, const real32_t *op2, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ goto ("							\n		""""movs""s""		%1, %%xmm0			\n		""""ucomis""s""		%2, %%xmm0			\n		jp			%l[unordered]			\n		""setb""		%0				\n	" : : "m"(*res), "m"(*op1), "m"(*op2) : "memory", "cc" , "xmm0" : unordered); return 1; unordered: return 0; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_less_equal_alt1_real32_t(const real32_t *op1, const real32_t *op2, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ goto ("							\n		""""movs""s""		%1, %%xmm0			\n		""""ucomis""s""		%2, %%xmm0			\n		jp			%l[unordered]			\n		""setbe""		%0				\n	" : : "m"(*res), "m"(*op1), "m"(*op2) : "memory", "cc" , "xmm0" : unordered); return 1; unordered: return 0; } static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) REAL_unary_neg_alt1_real32_t(const real32_t *op1, real32_t *res){ static const real32_t x = -0.0; __asm__ ("									""""movs""s""	%1, %%xmm0				\n		""""movs""s""	%2, %%xmm1				\n		""""xorp""s""	%%xmm1, ""%%xmm0""			\n		""""movs""s""	%%xmm0, %0				\n	" : "=m"(*res) : "m"(*op1), "m"(x) : "xmm0" , "xmm1");} static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) REAL_unary_sqrt_alt1_real32_t(const real32_t *op1, real32_t *res){ __asm__ ("									""""movs""s""	%1, %%xmm0				\n		""""sqrts""s""	%%xmm0, ""%%xmm0""			\n		""""movs""s""	%%xmm0, %0				\n	" : "=m"(*res) : "m"(*op1) : "xmm0" , "xmm1");} static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_unary_to_int_alt1_real32_t(const real32_t *op1, int64_t *res){ int64_t r; __asm__ ("							\n		""""cvtts""s""2si	%1, %0					\n	" : "=r"(r) : "m"(*op1)); if ((__builtin_expect((int)(r == ((int64_t)(-((int64_t)1 << (8 * sizeof(int64_t) - 2)) * 2))), 0))) return 0; *res = r; return 1; } static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) REAL_unary_from_int_alt1_real32_t(const int64_t *op1, real32_t *res){ __asm__ ("							\n		""""cvtsi2s""s""""q""	%1, ""%%xmm0""			\n		""""movs""s""		%%xmm0, %0			\n	" : "=m"(*res) : "rm"(*op1) : "xmm0"); } static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) REAL_unary_is_exception_alt1_real32_t(const real32_t *op1, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ ("									""""movs""s""		%1, %%xmm0			\n		""""ucomis""s""		%%xmm0, %%xmm0			\n		setp			%0				\n	" : "=m"(*res) : "m"(*op1) : "cc" , "xmm0"); }
# 47 "./arithm-r.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_add_alt2_real32_t(const real32_t *op1, const real32_t *op2, real32_t *res){ __asm__ ("							\n		""v""movs""s""		%1, %%xmm0			\n		""v""""add""s""s""	%2, ""%%xmm0"", ""%%xmm0""			\n		""v""movs""s""		%%xmm0, %0			\n	" : "=m"(*res) : "m"(*op1), "m"(*op2) : "xmm0"); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_subtract_alt2_real32_t(const real32_t *op1, const real32_t *op2, real32_t *res){ __asm__ ("							\n		""v""movs""s""		%1, %%xmm0			\n		""v""""sub""s""s""	%2, ""%%xmm0"", ""%%xmm0""			\n		""v""movs""s""		%%xmm0, %0			\n	" : "=m"(*res) : "m"(*op1), "m"(*op2) : "xmm0"); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_multiply_alt2_real32_t(const real32_t *op1, const real32_t *op2, real32_t *res){ __asm__ ("							\n		""v""movs""s""		%1, %%xmm0			\n		""v""""mul""s""s""	%2, ""%%xmm0"", ""%%xmm0""			\n		""v""movs""s""		%%xmm0, %0			\n	" : "=m"(*res) : "m"(*op1), "m"(*op2) : "xmm0"); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_divide_alt2_real32_t(const real32_t *op1, const real32_t *op2, real32_t *res){ __asm__ ("							\n		""v""movs""s""		%1, %%xmm0			\n		""v""""div""s""s""	%2, ""%%xmm0"", ""%%xmm0""			\n		""v""movs""s""		%%xmm0, %0			\n	" : "=m"(*res) : "m"(*op1), "m"(*op2) : "xmm0"); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_equal_alt2_real32_t(const real32_t *op1, const real32_t *op2, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ goto ("							\n		""v""movs""s""		%1, %%xmm0			\n		""v""ucomis""s""		%2, %%xmm0			\n		jp			%l[unordered]			\n		""sete""		%0				\n	" : : "m"(*res), "m"(*op1), "m"(*op2) : "memory", "cc" , "xmm0" : unordered); return 1; unordered: return 0; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_not_equal_alt2_real32_t(const real32_t *op1, const real32_t *op2, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ goto ("							\n		""v""movs""s""		%1, %%xmm0			\n		""v""ucomis""s""		%2, %%xmm0			\n		jp			%l[unordered]			\n		""setne""		%0				\n	" : : "m"(*res), "m"(*op1), "m"(*op2) : "memory", "cc" , "xmm0" : unordered); return 1; unordered: return 0; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_less_alt2_real32_t(const real32_t *op1, const real32_t *op2, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ goto ("							\n		""v""movs""s""		%1, %%xmm0			\n		""v""ucomis""s""		%2, %%xmm0			\n		jp			%l[unordered]			\n		""setb""		%0				\n	" : : "m"(*res), "m"(*op1), "m"(*op2) : "memory", "cc" , "xmm0" : unordered); return 1; unordered: return 0; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_less_equal_alt2_real32_t(const real32_t *op1, const real32_t *op2, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ goto ("							\n		""v""movs""s""		%1, %%xmm0			\n		""v""ucomis""s""		%2, %%xmm0			\n		jp			%l[unordered]			\n		""setbe""		%0				\n	" : : "m"(*res), "m"(*op1), "m"(*op2) : "memory", "cc" , "xmm0" : unordered); return 1; unordered: return 0; } static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) REAL_unary_neg_alt2_real32_t(const real32_t *op1, real32_t *res){ static const real32_t x = -0.0; __asm__ ("									""v""movs""s""	%1, %%xmm0				\n		""v""movs""s""	%2, %%xmm1				\n		""v""xorp""s""	%%xmm1, ""%%xmm0"", ""%%xmm0""			\n		""v""movs""s""	%%xmm0, %0				\n	" : "=m"(*res) : "m"(*op1), "m"(x) : "xmm0" , "xmm1");} static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) REAL_unary_sqrt_alt2_real32_t(const real32_t *op1, real32_t *res){ __asm__ ("									""v""movs""s""	%1, %%xmm0				\n		""v""sqrts""s""	%%xmm0, ""%%xmm0"", ""%%xmm0""			\n		""v""movs""s""	%%xmm0, %0				\n	" : "=m"(*res) : "m"(*op1) : "xmm0" , "xmm1");} static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_unary_to_int_alt2_real32_t(const real32_t *op1, int64_t *res){ int64_t r; __asm__ ("							\n		""v""cvtts""s""2si	%1, %0					\n	" : "=r"(r) : "m"(*op1)); if ((__builtin_expect((int)(r == ((int64_t)(-((int64_t)1 << (8 * sizeof(int64_t) - 2)) * 2))), 0))) return 0; *res = r; return 1; } static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) REAL_unary_from_int_alt2_real32_t(const int64_t *op1, real32_t *res){ __asm__ ("							\n		""v""cvtsi2s""s""""q""	%1, ""%%xmm0"", ""%%xmm0""			\n		""v""movs""s""		%%xmm0, %0			\n	" : "=m"(*res) : "rm"(*op1) : "xmm0"); } static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) REAL_unary_is_exception_alt2_real32_t(const real32_t *op1, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ ("									""v""movs""s""		%1, %%xmm0			\n		""v""ucomis""s""		%%xmm0, %%xmm0			\n		setp			%0				\n	" : "=m"(*res) : "m"(*op1) : "cc" , "xmm0"); }
# 34 "./for-real.inc" 2
# 43 "./for-real.inc"
# 1 "./arithm-r.inc" 1
# 42 "./arithm-r.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_add_alt1_real64_t(const real64_t *op1, const real64_t *op2, real64_t *res){ __asm__ ("							\n		""""movs""d""		%1, %%xmm0			\n		""""""add""s""d""	%2, ""%%xmm0""			\n		""""movs""d""		%%xmm0, %0			\n	" : "=m"(*res) : "m"(*op1), "m"(*op2) : "xmm0"); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_subtract_alt1_real64_t(const real64_t *op1, const real64_t *op2, real64_t *res){ __asm__ ("							\n		""""movs""d""		%1, %%xmm0			\n		""""""sub""s""d""	%2, ""%%xmm0""			\n		""""movs""d""		%%xmm0, %0			\n	" : "=m"(*res) : "m"(*op1), "m"(*op2) : "xmm0"); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_multiply_alt1_real64_t(const real64_t *op1, const real64_t *op2, real64_t *res){ __asm__ ("							\n		""""movs""d""		%1, %%xmm0			\n		""""""mul""s""d""	%2, ""%%xmm0""			\n		""""movs""d""		%%xmm0, %0			\n	" : "=m"(*res) : "m"(*op1), "m"(*op2) : "xmm0"); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_divide_alt1_real64_t(const real64_t *op1, const real64_t *op2, real64_t *res){ __asm__ ("							\n		""""movs""d""		%1, %%xmm0			\n		""""""div""s""d""	%2, ""%%xmm0""			\n		""""movs""d""		%%xmm0, %0			\n	" : "=m"(*res) : "m"(*op1), "m"(*op2) : "xmm0"); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_equal_alt1_real64_t(const real64_t *op1, const real64_t *op2, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ goto ("							\n		""""movs""d""		%1, %%xmm0			\n		""""ucomis""d""		%2, %%xmm0			\n		jp			%l[unordered]			\n		""sete""		%0				\n	" : : "m"(*res), "m"(*op1), "m"(*op2) : "memory", "cc" , "xmm0" : unordered); return 1; unordered: return 0; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_not_equal_alt1_real64_t(const real64_t *op1, const real64_t *op2, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ goto ("							\n		""""movs""d""		%1, %%xmm0			\n		""""ucomis""d""		%2, %%xmm0			\n		jp			%l[unordered]			\n		""setne""		%0				\n	" : : "m"(*res), "m"(*op1), "m"(*op2) : "memory", "cc" , "xmm0" : unordered); return 1; unordered: return 0; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_less_alt1_real64_t(const real64_t *op1, const real64_t *op2, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ goto ("							\n		""""movs""d""		%1, %%xmm0			\n		""""ucomis""d""		%2, %%xmm0			\n		jp			%l[unordered]			\n		""setb""		%0				\n	" : : "m"(*res), "m"(*op1), "m"(*op2) : "memory", "cc" , "xmm0" : unordered); return 1; unordered: return 0; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_less_equal_alt1_real64_t(const real64_t *op1, const real64_t *op2, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ goto ("							\n		""""movs""d""		%1, %%xmm0			\n		""""ucomis""d""		%2, %%xmm0			\n		jp			%l[unordered]			\n		""setbe""		%0				\n	" : : "m"(*res), "m"(*op1), "m"(*op2) : "memory", "cc" , "xmm0" : unordered); return 1; unordered: return 0; } static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) REAL_unary_neg_alt1_real64_t(const real64_t *op1, real64_t *res){ static const real64_t x = -0.0; __asm__ ("									""""movs""d""	%1, %%xmm0				\n		""""movs""d""	%2, %%xmm1				\n		""""xorp""d""	%%xmm1, ""%%xmm0""			\n		""""movs""d""	%%xmm0, %0				\n	" : "=m"(*res) : "m"(*op1), "m"(x) : "xmm0" , "xmm1");} static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) REAL_unary_sqrt_alt1_real64_t(const real64_t *op1, real64_t *res){ __asm__ ("									""""movs""d""	%1, %%xmm0				\n		""""sqrts""d""	%%xmm0, ""%%xmm0""			\n		""""movs""d""	%%xmm0, %0				\n	" : "=m"(*res) : "m"(*op1) : "xmm0" , "xmm1");} static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_unary_to_int_alt1_real64_t(const real64_t *op1, int64_t *res){ int64_t r; __asm__ ("							\n		""""cvtts""d""2si	%1, %0					\n	" : "=r"(r) : "m"(*op1)); if ((__builtin_expect((int)(r == ((int64_t)(-((int64_t)1 << (8 * sizeof(int64_t) - 2)) * 2))), 0))) return 0; *res = r; return 1; } static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) REAL_unary_from_int_alt1_real64_t(const int64_t *op1, real64_t *res){ __asm__ ("							\n		""""cvtsi2s""d""""q""	%1, ""%%xmm0""			\n		""""movs""d""		%%xmm0, %0			\n	" : "=m"(*res) : "rm"(*op1) : "xmm0"); } static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) REAL_unary_is_exception_alt1_real64_t(const real64_t *op1, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ ("									""""movs""d""		%1, %%xmm0			\n		""""ucomis""d""		%%xmm0, %%xmm0			\n		setp			%0				\n	" : "=m"(*res) : "m"(*op1) : "cc" , "xmm0"); }
# 52 "./arithm-r.inc"
static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_add_alt2_real64_t(const real64_t *op1, const real64_t *op2, real64_t *res){ __asm__ ("							\n		""v""movs""d""		%1, %%xmm0			\n		""v""""add""s""d""	%2, ""%%xmm0"", ""%%xmm0""			\n		""v""movs""d""		%%xmm0, %0			\n	" : "=m"(*res) : "m"(*op1), "m"(*op2) : "xmm0"); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_subtract_alt2_real64_t(const real64_t *op1, const real64_t *op2, real64_t *res){ __asm__ ("							\n		""v""movs""d""		%1, %%xmm0			\n		""v""""sub""s""d""	%2, ""%%xmm0"", ""%%xmm0""			\n		""v""movs""d""		%%xmm0, %0			\n	" : "=m"(*res) : "m"(*op1), "m"(*op2) : "xmm0"); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_multiply_alt2_real64_t(const real64_t *op1, const real64_t *op2, real64_t *res){ __asm__ ("							\n		""v""movs""d""		%1, %%xmm0			\n		""v""""mul""s""d""	%2, ""%%xmm0"", ""%%xmm0""			\n		""v""movs""d""		%%xmm0, %0			\n	" : "=m"(*res) : "m"(*op1), "m"(*op2) : "xmm0"); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_divide_alt2_real64_t(const real64_t *op1, const real64_t *op2, real64_t *res){ __asm__ ("							\n		""v""movs""d""		%1, %%xmm0			\n		""v""""div""s""d""	%2, ""%%xmm0"", ""%%xmm0""			\n		""v""movs""d""		%%xmm0, %0			\n	" : "=m"(*res) : "m"(*op1), "m"(*op2) : "xmm0"); return 1; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_equal_alt2_real64_t(const real64_t *op1, const real64_t *op2, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ goto ("							\n		""v""movs""d""		%1, %%xmm0			\n		""v""ucomis""d""		%2, %%xmm0			\n		jp			%l[unordered]			\n		""sete""		%0				\n	" : : "m"(*res), "m"(*op1), "m"(*op2) : "memory", "cc" , "xmm0" : unordered); return 1; unordered: return 0; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_not_equal_alt2_real64_t(const real64_t *op1, const real64_t *op2, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ goto ("							\n		""v""movs""d""		%1, %%xmm0			\n		""v""ucomis""d""		%2, %%xmm0			\n		jp			%l[unordered]			\n		""setne""		%0				\n	" : : "m"(*res), "m"(*op1), "m"(*op2) : "memory", "cc" , "xmm0" : unordered); return 1; unordered: return 0; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_less_alt2_real64_t(const real64_t *op1, const real64_t *op2, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ goto ("							\n		""v""movs""d""		%1, %%xmm0			\n		""v""ucomis""d""		%2, %%xmm0			\n		jp			%l[unordered]			\n		""setb""		%0				\n	" : : "m"(*res), "m"(*op1), "m"(*op2) : "memory", "cc" , "xmm0" : unordered); return 1; unordered: return 0; } static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_binary_less_equal_alt2_real64_t(const real64_t *op1, const real64_t *op2, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ goto ("							\n		""v""movs""d""		%1, %%xmm0			\n		""v""ucomis""d""		%2, %%xmm0			\n		jp			%l[unordered]			\n		""setbe""		%0				\n	" : : "m"(*res), "m"(*op1), "m"(*op2) : "memory", "cc" , "xmm0" : unordered); return 1; unordered: return 0; } static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) REAL_unary_neg_alt2_real64_t(const real64_t *op1, real64_t *res){ static const real64_t x = -0.0; __asm__ ("									""v""movs""d""	%1, %%xmm0				\n		""v""movs""d""	%2, %%xmm1				\n		""v""xorp""d""	%%xmm1, ""%%xmm0"", ""%%xmm0""			\n		""v""movs""d""	%%xmm0, %0				\n	" : "=m"(*res) : "m"(*op1), "m"(x) : "xmm0" , "xmm1");} static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) REAL_unary_sqrt_alt2_real64_t(const real64_t *op1, real64_t *res){ __asm__ ("									""v""movs""d""	%1, %%xmm0				\n		""v""sqrts""d""	%%xmm0, ""%%xmm0"", ""%%xmm0""			\n		""v""movs""d""	%%xmm0, %0				\n	" : "=m"(*res) : "m"(*op1) : "xmm0" , "xmm1");} static inline __attribute__((__always_inline__)) _Bool __attribute__((__unused__)) REAL_unary_to_int_alt2_real64_t(const real64_t *op1, int64_t *res){ int64_t r; __asm__ ("							\n		""v""cvtts""d""2si	%1, %0					\n	" : "=r"(r) : "m"(*op1)); if ((__builtin_expect((int)(r == ((int64_t)(-((int64_t)1 << (8 * sizeof(int64_t) - 2)) * 2))), 0))) return 0; *res = r; return 1; } static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) REAL_unary_from_int_alt2_real64_t(const int64_t *op1, real64_t *res){ __asm__ ("							\n		""v""cvtsi2s""d""""q""	%1, ""%%xmm0"", ""%%xmm0""			\n		""v""movs""d""		%%xmm0, %0			\n	" : "=m"(*res) : "rm"(*op1) : "xmm0"); } static inline __attribute__((__always_inline__)) void __attribute__((__unused__)) REAL_unary_is_exception_alt2_real64_t(const real64_t *op1, ajla_flat_option_t *res){ if (sizeof(ajla_flat_option_t) != 1) *res = 0; __asm__ ("									""v""movs""d""		%1, %%xmm0			\n		""v""ucomis""d""		%%xmm0, %%xmm0			\n		setp			%0				\n	" : "=m"(*res) : "m"(*op1) : "cc" , "xmm0"); }
# 44 "./for-real.inc" 2
# 53 "./for-real.inc"
# 1 "./arithm-r.inc" 1
# 54 "./for-real.inc" 2
# 541 "./arithm-r.h" 2
# 31 "ipret.c" 2

# 1 "./task.h" 1
# 34 "./task.h"
extern uint32_t nr_cpus_override;

void u_task_submit(struct execution_control *ex, _Bool can_allocate_memory);

void * u_task_schedule(struct execution_control *ex);

void u_waiting_list_add(struct execution_control *ex);
void u_waiting_list_remove(struct execution_control *ex);
_Bool u_waiting_list_break(void);
# 51 "./task.h"
void u_task_ex_control_started(void);
void u_task_ex_control_exited(void);
void u_task_program_started(void);
void u_task_program_exited(void);
# 33 "ipret.c" 2
# 1 "./ipfn.h" 1
# 23 "./ipfn.h"
# 1 "./ipunalg.h" 1
# 24 "./ipunalg.h"
static inline __attribute__((__always_inline__)) uint8_t get_unaligned_8(const code_t *p)
{
 return (uint8_t)*p;
}

static inline __attribute__((__always_inline__)) uint16_t get_unaligned_16(const code_t *p)
{
 return *p;
}

static inline __attribute__((__always_inline__)) uint32_t get_unaligned_32(const code_t *p)
{

 struct unaligned_32 { uint32_t val; } __attribute__((packed));
 return ((const struct unaligned_32 *)(void *)(p))->val;



}


static inline uint64_t get_unaligned_64(const code_t *p)
{

 struct unaligned_64 { uint64_t val; } __attribute__((packed));
 return ((const struct unaligned_64 *)(void *)(p))->val;



}



static inline uint128_t get_unaligned_128(const code_t *p)
{

 struct unaligned_128 { uint128_t val; } __attribute__((packed));
 return ((const struct unaligned_128 *)(void *)(p))->val;



}
# 24 "./ipfn.h" 2
# 74 "./ipfn.h"
extern _Bool ipret_strict_calls;
extern _Bool ipret_is_privileged;
extern _Bool ipret_compile;

void u_eval_both(frame_s *fp, const code_t *ip, frame_t slot_1, frame_t slot_2);

void u_ipret_fill_function_reference_from_slot(struct data *function_reference, arg_t a, frame_s *fp, frame_t slot, _Bool deref);

void * u_thunk_fixed_operator(frame_s *fp, const code_t *ip, frame_t slot_1, frame_t slot_2, frame_t slot_r, unsigned strict_flag);
void * u_is_thunk_operator(frame_s *fp, const code_t *ip, frame_t slot_1, frame_t slot_r, unsigned strict_flag);
void * u_thunk_get_param(frame_s *fp, const code_t *ip, frame_t slot_1, frame_t slot_r, unsigned strict_flag, unsigned mode);
int64_t u_ipret_system_property(int64_t idx);
void * u_ipret_get_system_property(frame_s *fp, const code_t *ip, frame_t slot_1, frame_t slot_r);

void * u_thunk_int_binary_operator(frame_s *fp, const code_t *ip, frame_t slot_1, frame_t slot_2, frame_t slot_r, unsigned strict_flag, _Bool ( *do_op)(const mpint_t *op1, const mpint_t *op2, mpint_t *res, ajla_error_t *err));
void * u_thunk_int_unary_operator(frame_s *fp, const code_t *ip, frame_t slot_1, frame_t slot_r, unsigned strict_flag, _Bool ( *do_op)(const mpint_t *op1, mpint_t *res, ajla_error_t *err));
void * u_thunk_int_binary_logical_operator(frame_s *fp, const code_t *ip, frame_t slot_1, frame_t slot_2, frame_t slot_r, unsigned strict_flag, _Bool ( *do_op)(const mpint_t *op1, const mpint_t *op2, ajla_flat_option_t *res, ajla_error_t *err));
ip_t u_ipret_int_ldc_long(frame_s *fp, frame_t slot, const code_t *ip);
pointer_t u_convert_fixed_to_mpint(uintbig_t val, _Bool uns);
pointer_t u_convert_real_to_mpint(frame_s *fp, frame_t src_slot, const struct type *src_type);
void * u_thunk_convert(frame_s *fp, const code_t *ip, frame_t src_slot, frame_t dest_slot, unsigned strict_flag);

void * u_thunk_bool_operator(frame_s *fp, const code_t *ip, frame_t slot_1, frame_t slot_2, frame_t slot_r, unsigned strict_flag);
void * u_thunk_bool_jump(frame_s *fp, const code_t *ip, frame_t slot);

void u_ipret_copy_variable(frame_s *src_fp, frame_t src_slot, frame_s *dst_fp, frame_t dst_slot, _Bool deref);
pointer_t u_ipret_copy_variable_to_pointer(frame_s *src_fp, frame_t src_slot, _Bool deref);

struct ipret_call_cache_arg {
 struct function_argument *f_arg;
 frame_t slot;
 _Bool deref;
 _Bool need_free_ptr;
 pointer_t ptr;
};
void * u_ipret_call_cache(frame_s *fp, const code_t *ip, pointer_t *direct_function, struct ipret_call_cache_arg *arguments, frame_t *return_values, frame_t free_fn_slot);

void * u_ipret_get_index(frame_s *fp, const code_t *ip, frame_s *fp_slot, frame_t slot, _Bool *is_negative, array_index_t *idx, pointer_t *thunk , const char __attribute__((__unused__)) *position_arg);

void * u_ipret_record_load_create_thunk(frame_s *fp, const code_t *ip, frame_t record, frame_t record_slot, frame_t result_slot);
void * u_ipret_option_load_create_thunk(frame_s *fp, const code_t *ip, frame_t option, frame_t option_idx, frame_t result_slot);
void * u_thunk_option_test(frame_s *fp, const code_t *ip, frame_t slot_1, ajla_option_t option, frame_t slot_r);
void * u_thunk_option_ord(frame_s *fp, const code_t *ip, frame_t slot_1, frame_t slot_r);
void * u_ipret_array_load_create_thunk(frame_s *fp, const code_t *ip, frame_t array, frame_t index, frame_t result_slot);
void * u_ipret_array_len(frame_s *fp, const code_t *ip, frame_t slot_r, frame_t slot_a, unsigned flags);
void * u_ipret_array_len_greater_than(frame_s *fp, const code_t *ip, frame_t slot_r, frame_t slot_a, frame_t l, unsigned flags);
void * u_ipret_array_sub(frame_s *fp, const code_t *ip, frame_t slot_r, frame_t slot_a, frame_t slot_start, frame_t slot_end, unsigned flags);
void * u_ipret_array_skip(frame_s *fp, const code_t *ip, frame_t slot_r, frame_t slot_a, frame_t slot_start, unsigned flags);
void * u_ipret_array_append(frame_s *fp, const code_t *ip, frame_t slot_r, frame_t slot_1, frame_t slot_2, unsigned flags);
void * u_ipret_array_append_one_flat(frame_s *fp, const code_t *ip, frame_t slot_r, frame_t slot_1, frame_t slot_2, unsigned flags);
void * u_ipret_array_append_one(frame_s *fp, const code_t *ip, frame_t slot_r, frame_t slot_1, frame_t slot_2, unsigned flags);
void * u_ipret_array_flatten(frame_s *fp, const code_t *ip, frame_t slot_r, frame_t slot_1, unsigned flags);

void u_ipret_prefetch_functions(struct data *function);
_Bool u_ipret_break_waiting_chain(frame_s *fp, ip_t ip);
void * u_ipret_tick(frame_s *fp, const code_t *ip);
# 34 "ipret.c" 2
# 1 "./ipio.h" 1
# 26 "./ipio.h"
void *u_ipret_io(frame_s *fp, const code_t *ip, unsigned char io_code, unsigned char n_outputs, unsigned char n_inputs, unsigned char n_params);
# 35 "ipret.c" 2

# 1 "./codegen.h" 1
# 30 "./codegen.h"
void *u_codegen_fn(frame_s *fp, const code_t *ip, union internal_arg ia[]);
void u_codegen_free(struct data *codegen);
typedef code_return_t (*codegen_type)(frame_s *, struct cg_upcall_vector_s *, tick_stamp_t, void *);
extern codegen_type u_codegen_entry;
# 37 "ipret.c" 2

# 1 "./ipret.h" 1
# 37 "./ipret.h"
void u_run(frame_s *, ip_t);

struct cg_upcall_vector_s {
 _Atomic tick_stamp_t ts;

 void (*mem_copy)(void *dest, const void *src, size_t size);
 void (*mem_clear)(void *ptr, size_t size);
 void (*cg_upcall_pointer_dereference)(pointer_t ptr);
 void (*cg_upcall_pointer_reference_owned)(pointer_t ptr);
 pointer_t (*cg_upcall_flat_to_data)(frame_s *fp, uintptr_t slot, const unsigned char *flat);
 unsigned char *(*cg_upcall_data_alloc_function_reference_mayfail)(uintptr_t n_curried_arguments);
 unsigned char *(*cg_upcall_data_alloc_record_mayfail)(frame_s *fp, uintptr_t slot);
 unsigned char *(*cg_upcall_data_alloc_option_mayfail)(void);
 unsigned char *(*cg_upcall_data_alloc_array_flat_tag_mayfail)(uintptr_t t, int64_t n_entries);
 unsigned char *(*cg_upcall_data_alloc_array_flat_slot_mayfail)(frame_s *fp, uintptr_t slot, int64_t n_entries);
 unsigned char *(*cg_upcall_data_alloc_array_flat_types_ptr_mayfail)(frame_s *fp, uintptr_t local_type, int64_t n_entries);
 unsigned char *(*cg_upcall_data_alloc_array_pointers_mayfail)(int64_t n_allocated, int64_t n_used);
 pointer_t (*cg_upcall_array_create_flat)(frame_s *fp, int64_t length, uintptr_t content_slot);
 pointer_t (*cg_upcall_array_create_pointers)(frame_s *fp, uintptr_t ip_offset, uintptr_t length_slot, pointer_t ptr);
 pointer_t (*cg_upcall_array_create_sparse)(int64_t length, pointer_t ptr);
 pointer_t (*cg_upcall_array_sub)(pointer_t array, int64_t start, int64_t end, _Bool deref);
 pointer_t (*cg_upcall_array_skip)(pointer_t array, int64_t start, _Bool deref);
 pointer_t (*cg_upcall_array_join)(pointer_t ptr1, pointer_t ptr2);
 void *(*cg_upcall_ipret_io)(frame_s *fp, uintptr_t ip_offset, uintptr_t code_params);
 pointer_t (*cg_upcall_ipret_copy_variable_to_pointer)(frame_s *src_fp, uintptr_t src_slot, _Bool deref);
 int64_t (*u_ipret_system_property)(int64_t idx);
 _Bool (*FIXED_binary_add_int128_t)(const uintbig_t *v1, const uintbig_t *v2, uintbig_t *r);
 _Bool (*FIXED_binary_subtract_int128_t)(const uintbig_t *v1, const uintbig_t *v2, uintbig_t *r);


 _Bool (*FIXED_binary_multiply_int8_t)(const uint8_t *v1, const uint8_t *v2, uint8_t *r); _Bool (*FIXED_binary_multiply_int16_t)(const uint16_t *v1, const uint16_t *v2, uint16_t *r); _Bool (*FIXED_binary_multiply_int32_t)(const uint32_t *v1, const uint32_t *v2, uint32_t *r); _Bool (*FIXED_binary_multiply_int64_t)(const uint64_t *v1, const uint64_t *v2, uint64_t *r); _Bool (*FIXED_binary_multiply_int128_t)(const uint128_t *v1, const uint128_t *v2, uint128_t *r);



 _Bool (*FIXED_binary_divide_int8_t)(const uint8_t *v1, const uint8_t *v2, uint8_t *r); _Bool (*FIXED_binary_divide_int16_t)(const uint16_t *v1, const uint16_t *v2, uint16_t *r); _Bool (*FIXED_binary_divide_int32_t)(const uint32_t *v1, const uint32_t *v2, uint32_t *r); _Bool (*FIXED_binary_divide_int64_t)(const uint64_t *v1, const uint64_t *v2, uint64_t *r); _Bool (*FIXED_binary_divide_int128_t)(const uint128_t *v1, const uint128_t *v2, uint128_t *r);



 _Bool (*FIXED_binary_udivide_int8_t)(const uint8_t *v1, const uint8_t *v2, uint8_t *r); _Bool (*FIXED_binary_udivide_int16_t)(const uint16_t *v1, const uint16_t *v2, uint16_t *r); _Bool (*FIXED_binary_udivide_int32_t)(const uint32_t *v1, const uint32_t *v2, uint32_t *r); _Bool (*FIXED_binary_udivide_int64_t)(const uint64_t *v1, const uint64_t *v2, uint64_t *r); _Bool (*FIXED_binary_udivide_int128_t)(const uint128_t *v1, const uint128_t *v2, uint128_t *r);



 _Bool (*FIXED_binary_modulo_int8_t)(const uint8_t *v1, const uint8_t *v2, uint8_t *r); _Bool (*FIXED_binary_modulo_int16_t)(const uint16_t *v1, const uint16_t *v2, uint16_t *r); _Bool (*FIXED_binary_modulo_int32_t)(const uint32_t *v1, const uint32_t *v2, uint32_t *r); _Bool (*FIXED_binary_modulo_int64_t)(const uint64_t *v1, const uint64_t *v2, uint64_t *r); _Bool (*FIXED_binary_modulo_int128_t)(const uint128_t *v1, const uint128_t *v2, uint128_t *r);



 _Bool (*FIXED_binary_umodulo_int8_t)(const uint8_t *v1, const uint8_t *v2, uint8_t *r); _Bool (*FIXED_binary_umodulo_int16_t)(const uint16_t *v1, const uint16_t *v2, uint16_t *r); _Bool (*FIXED_binary_umodulo_int32_t)(const uint32_t *v1, const uint32_t *v2, uint32_t *r); _Bool (*FIXED_binary_umodulo_int64_t)(const uint64_t *v1, const uint64_t *v2, uint64_t *r); _Bool (*FIXED_binary_umodulo_int128_t)(const uint128_t *v1, const uint128_t *v2, uint128_t *r);



 _Bool (*FIXED_binary_power_int8_t)(const uint8_t *v1, const uint8_t *v2, uint8_t *r); _Bool (*FIXED_binary_power_int16_t)(const uint16_t *v1, const uint16_t *v2, uint16_t *r); _Bool (*FIXED_binary_power_int32_t)(const uint32_t *v1, const uint32_t *v2, uint32_t *r); _Bool (*FIXED_binary_power_int64_t)(const uint64_t *v1, const uint64_t *v2, uint64_t *r); _Bool (*FIXED_binary_power_int128_t)(const uint128_t *v1, const uint128_t *v2, uint128_t *r);

 _Bool (*FIXED_binary_shl_int128_t)(const uintbig_t *v1, const uintbig_t *v2, uintbig_t *r);
 _Bool (*FIXED_binary_shr_int128_t)(const uintbig_t *v1, const uintbig_t *v2, uintbig_t *r);
 _Bool (*FIXED_binary_ushr_int128_t)(const uintbig_t *v1, const uintbig_t *v2, uintbig_t *r);
 _Bool (*FIXED_binary_rol_int128_t)(const uintbig_t *v1, const uintbig_t *v2, uintbig_t *r);
 _Bool (*FIXED_binary_ror_int128_t)(const uintbig_t *v1, const uintbig_t *v2, uintbig_t *r);
 _Bool (*FIXED_binary_bts_int128_t)(const uintbig_t *v1, const uintbig_t *v2, uintbig_t *r);
 _Bool (*FIXED_binary_btr_int128_t)(const uintbig_t *v1, const uintbig_t *v2, uintbig_t *r);
 _Bool (*FIXED_binary_btc_int128_t)(const uintbig_t *v1, const uintbig_t *v2, uintbig_t *r);
 _Bool (*FIXED_binary_less_int128_t)(const uintbig_t *v1, const uintbig_t *v2, ajla_flat_option_t *r);
 _Bool (*FIXED_binary_less_equal_int128_t)(const uintbig_t *v1, const uintbig_t *v2, ajla_flat_option_t *r);
 _Bool (*FIXED_binary_uless_int128_t)(const uintbig_t *v1, const uintbig_t *v2, ajla_flat_option_t *r);
 _Bool (*FIXED_binary_uless_equal_int128_t)(const uintbig_t *v1, const uintbig_t *v2, ajla_flat_option_t *r);
 _Bool (*FIXED_binary_bt_int128_t)(const uintbig_t *v1, const uintbig_t *v2, ajla_flat_option_t *r);
 void (*FIXED_unary_neg_int128_t)(const uintbig_t *v1, uintbig_t *r);
 void (*FIXED_unary_inc_int128_t)(const uintbig_t *v1, uintbig_t *r);
 void (*FIXED_unary_dec_int128_t)(const uintbig_t *v1, uintbig_t *r);


 void (*FIXED_unary_bswap_int8_t)(const uint8_t *v1, uint8_t *r); void (*FIXED_unary_bswap_int16_t)(const uint16_t *v1, uint16_t *r); void (*FIXED_unary_bswap_int32_t)(const uint32_t *v1, uint32_t *r); void (*FIXED_unary_bswap_int64_t)(const uint64_t *v1, uint64_t *r); void (*FIXED_unary_bswap_int128_t)(const uint128_t *v1, uint128_t *r);



 void (*FIXED_unary_brev_int8_t)(const uint8_t *v1, uint8_t *r); void (*FIXED_unary_brev_int16_t)(const uint16_t *v1, uint16_t *r); void (*FIXED_unary_brev_int32_t)(const uint32_t *v1, uint32_t *r); void (*FIXED_unary_brev_int64_t)(const uint64_t *v1, uint64_t *r); void (*FIXED_unary_brev_int128_t)(const uint128_t *v1, uint128_t *r);



 void (*FIXED_unary_bsf_int8_t)(const uint8_t *v1, uint8_t *r); void (*FIXED_unary_bsf_int16_t)(const uint16_t *v1, uint16_t *r); void (*FIXED_unary_bsf_int32_t)(const uint32_t *v1, uint32_t *r); void (*FIXED_unary_bsf_int64_t)(const uint64_t *v1, uint64_t *r); void (*FIXED_unary_bsf_int128_t)(const uint128_t *v1, uint128_t *r);



 void (*FIXED_unary_bsr_int8_t)(const uint8_t *v1, uint8_t *r); void (*FIXED_unary_bsr_int16_t)(const uint16_t *v1, uint16_t *r); void (*FIXED_unary_bsr_int32_t)(const uint32_t *v1, uint32_t *r); void (*FIXED_unary_bsr_int64_t)(const uint64_t *v1, uint64_t *r); void (*FIXED_unary_bsr_int128_t)(const uint128_t *v1, uint128_t *r);



 void (*FIXED_unary_popcnt_int8_t)(const uint8_t *v1, uint8_t *r); void (*FIXED_unary_popcnt_int16_t)(const uint16_t *v1, uint16_t *r); void (*FIXED_unary_popcnt_int32_t)(const uint32_t *v1, uint32_t *r); void (*FIXED_unary_popcnt_int64_t)(const uint64_t *v1, uint64_t *r); void (*FIXED_unary_popcnt_int128_t)(const uint128_t *v1, uint128_t *r);



 _Bool (*FIXED_uto_int_int8_t)(const uint8_t *v1, int64_t *r); _Bool (*FIXED_uto_int_int16_t)(const uint16_t *v1, int64_t *r); _Bool (*FIXED_uto_int_int32_t)(const uint32_t *v1, int64_t *r); _Bool (*FIXED_uto_int_int64_t)(const uint64_t *v1, int64_t *r); _Bool (*FIXED_uto_int_int128_t)(const uint128_t *v1, int64_t *r);



 _Bool (*FIXED_ufrom_int_int8_t)(const int64_t *v1, uint8_t *r); _Bool (*FIXED_ufrom_int_int16_t)(const int64_t *v1, uint16_t *r); _Bool (*FIXED_ufrom_int_int32_t)(const int64_t *v1, uint32_t *r); _Bool (*FIXED_ufrom_int_int64_t)(const int64_t *v1, uint64_t *r); _Bool (*FIXED_ufrom_int_int128_t)(const int64_t *v1, uint128_t *r);

 _Bool (*INT_binary_add_int128_t)(const intbig_t *v1, const intbig_t *v2, intbig_t *r);
 _Bool (*INT_binary_subtract_int128_t)(const intbig_t *v1, const intbig_t *v2, intbig_t *r);


 _Bool (*INT_binary_multiply_int8_t)(const int8_t *v1, const int8_t *v2, int8_t *r); _Bool (*INT_binary_multiply_int16_t)(const int16_t *v1, const int16_t *v2, int16_t *r); _Bool (*INT_binary_multiply_int32_t)(const int32_t *v1, const int32_t *v2, int32_t *r); _Bool (*INT_binary_multiply_int64_t)(const int64_t *v1, const int64_t *v2, int64_t *r); _Bool (*INT_binary_multiply_int128_t)(const int128_t *v1, const int128_t *v2, int128_t *r);



 _Bool (*INT_binary_divide_int8_t)(const int8_t *v1, const int8_t *v2, int8_t *r); _Bool (*INT_binary_divide_int16_t)(const int16_t *v1, const int16_t *v2, int16_t *r); _Bool (*INT_binary_divide_int32_t)(const int32_t *v1, const int32_t *v2, int32_t *r); _Bool (*INT_binary_divide_int64_t)(const int64_t *v1, const int64_t *v2, int64_t *r); _Bool (*INT_binary_divide_int128_t)(const int128_t *v1, const int128_t *v2, int128_t *r);



 _Bool (*INT_binary_modulo_int8_t)(const int8_t *v1, const int8_t *v2, int8_t *r); _Bool (*INT_binary_modulo_int16_t)(const int16_t *v1, const int16_t *v2, int16_t *r); _Bool (*INT_binary_modulo_int32_t)(const int32_t *v1, const int32_t *v2, int32_t *r); _Bool (*INT_binary_modulo_int64_t)(const int64_t *v1, const int64_t *v2, int64_t *r); _Bool (*INT_binary_modulo_int128_t)(const int128_t *v1, const int128_t *v2, int128_t *r);



 _Bool (*INT_binary_power_int8_t)(const int8_t *v1, const int8_t *v2, int8_t *r); _Bool (*INT_binary_power_int16_t)(const int16_t *v1, const int16_t *v2, int16_t *r); _Bool (*INT_binary_power_int32_t)(const int32_t *v1, const int32_t *v2, int32_t *r); _Bool (*INT_binary_power_int64_t)(const int64_t *v1, const int64_t *v2, int64_t *r); _Bool (*INT_binary_power_int128_t)(const int128_t *v1, const int128_t *v2, int128_t *r);

 _Bool (*INT_binary_shl_int128_t)(const intbig_t *v1, const intbig_t *v2, intbig_t *r);
 _Bool (*INT_binary_shr_int128_t)(const intbig_t *v1, const intbig_t *v2, intbig_t *r);
 _Bool (*INT_binary_bts_int128_t)(const intbig_t *v1, const intbig_t *v2, intbig_t *r);
 _Bool (*INT_binary_btr_int128_t)(const intbig_t *v1, const intbig_t *v2, intbig_t *r);
 _Bool (*INT_binary_btc_int128_t)(const intbig_t *v1, const intbig_t *v2, intbig_t *r);
 _Bool (*INT_binary_bt_int128_t)(const intbig_t *v1, const intbig_t *v2, ajla_flat_option_t *r);
 _Bool (*INT_unary_neg_int128_t)(const intbig_t *v1, intbig_t *r);
 _Bool (*INT_unary_inc_int128_t)(const intbig_t *v1, intbig_t *r);
 _Bool (*INT_unary_dec_int128_t)(const intbig_t *v1, intbig_t *r);


 _Bool (*INT_unary_bsf_int8_t)(const int8_t *v1, int8_t *r); _Bool (*INT_unary_bsf_int16_t)(const int16_t *v1, int16_t *r); _Bool (*INT_unary_bsf_int32_t)(const int32_t *v1, int32_t *r); _Bool (*INT_unary_bsf_int64_t)(const int64_t *v1, int64_t *r); _Bool (*INT_unary_bsf_int128_t)(const int128_t *v1, int128_t *r);



 _Bool (*INT_unary_bsr_int8_t)(const int8_t *v1, int8_t *r); _Bool (*INT_unary_bsr_int16_t)(const int16_t *v1, int16_t *r); _Bool (*INT_unary_bsr_int32_t)(const int32_t *v1, int32_t *r); _Bool (*INT_unary_bsr_int64_t)(const int64_t *v1, int64_t *r); _Bool (*INT_unary_bsr_int128_t)(const int128_t *v1, int128_t *r);



 _Bool (*INT_unary_popcnt_int8_t)(const int8_t *v1, int8_t *r); _Bool (*INT_unary_popcnt_int16_t)(const int16_t *v1, int16_t *r); _Bool (*INT_unary_popcnt_int32_t)(const int32_t *v1, int32_t *r); _Bool (*INT_unary_popcnt_int64_t)(const int64_t *v1, int64_t *r); _Bool (*INT_unary_popcnt_int128_t)(const int128_t *v1, int128_t *r);





 _Bool (*REAL_binary_add_real16_t)(const real16_t *v1, const real16_t *v2, real16_t *r); _Bool (*REAL_binary_add_real32_t)(const real32_t *v1, const real32_t *v2, real32_t *r); _Bool (*REAL_binary_add_real64_t)(const real64_t *v1, const real64_t *v2, real64_t *r); _Bool (*REAL_binary_add_real80_t)(const real80_t *v1, const real80_t *v2, real80_t *r);






 _Bool (*REAL_binary_subtract_real16_t)(const real16_t *v1, const real16_t *v2, real16_t *r); _Bool (*REAL_binary_subtract_real32_t)(const real32_t *v1, const real32_t *v2, real32_t *r); _Bool (*REAL_binary_subtract_real64_t)(const real64_t *v1, const real64_t *v2, real64_t *r); _Bool (*REAL_binary_subtract_real80_t)(const real80_t *v1, const real80_t *v2, real80_t *r);






 _Bool (*REAL_binary_multiply_real16_t)(const real16_t *v1, const real16_t *v2, real16_t *r); _Bool (*REAL_binary_multiply_real32_t)(const real32_t *v1, const real32_t *v2, real32_t *r); _Bool (*REAL_binary_multiply_real64_t)(const real64_t *v1, const real64_t *v2, real64_t *r); _Bool (*REAL_binary_multiply_real80_t)(const real80_t *v1, const real80_t *v2, real80_t *r);






 _Bool (*REAL_binary_divide_real16_t)(const real16_t *v1, const real16_t *v2, real16_t *r); _Bool (*REAL_binary_divide_real32_t)(const real32_t *v1, const real32_t *v2, real32_t *r); _Bool (*REAL_binary_divide_real64_t)(const real64_t *v1, const real64_t *v2, real64_t *r); _Bool (*REAL_binary_divide_real80_t)(const real80_t *v1, const real80_t *v2, real80_t *r);






 _Bool (*REAL_binary_modulo_real16_t)(const real16_t *v1, const real16_t *v2, real16_t *r); _Bool (*REAL_binary_modulo_real32_t)(const real32_t *v1, const real32_t *v2, real32_t *r); _Bool (*REAL_binary_modulo_real64_t)(const real64_t *v1, const real64_t *v2, real64_t *r); _Bool (*REAL_binary_modulo_real80_t)(const real80_t *v1, const real80_t *v2, real80_t *r);






 _Bool (*REAL_binary_power_real16_t)(const real16_t *v1, const real16_t *v2, real16_t *r); _Bool (*REAL_binary_power_real32_t)(const real32_t *v1, const real32_t *v2, real32_t *r); _Bool (*REAL_binary_power_real64_t)(const real64_t *v1, const real64_t *v2, real64_t *r); _Bool (*REAL_binary_power_real80_t)(const real80_t *v1, const real80_t *v2, real80_t *r);






 _Bool (*REAL_binary_ldexp_real16_t)(const real16_t *v1, const real16_t *v2, real16_t *r); _Bool (*REAL_binary_ldexp_real32_t)(const real32_t *v1, const real32_t *v2, real32_t *r); _Bool (*REAL_binary_ldexp_real64_t)(const real64_t *v1, const real64_t *v2, real64_t *r); _Bool (*REAL_binary_ldexp_real80_t)(const real80_t *v1, const real80_t *v2, real80_t *r);






 _Bool (*REAL_binary_atan2_real16_t)(const real16_t *v1, const real16_t *v2, real16_t *r); _Bool (*REAL_binary_atan2_real32_t)(const real32_t *v1, const real32_t *v2, real32_t *r); _Bool (*REAL_binary_atan2_real64_t)(const real64_t *v1, const real64_t *v2, real64_t *r); _Bool (*REAL_binary_atan2_real80_t)(const real80_t *v1, const real80_t *v2, real80_t *r);






 _Bool (*REAL_binary_equal_real16_t)(const real16_t *v1, const real16_t *v2, ajla_flat_option_t *r); _Bool (*REAL_binary_equal_real32_t)(const real32_t *v1, const real32_t *v2, ajla_flat_option_t *r); _Bool (*REAL_binary_equal_real64_t)(const real64_t *v1, const real64_t *v2, ajla_flat_option_t *r); _Bool (*REAL_binary_equal_real80_t)(const real80_t *v1, const real80_t *v2, ajla_flat_option_t *r);






 _Bool (*REAL_binary_not_equal_real16_t)(const real16_t *v1, const real16_t *v2, ajla_flat_option_t *r); _Bool (*REAL_binary_not_equal_real32_t)(const real32_t *v1, const real32_t *v2, ajla_flat_option_t *r); _Bool (*REAL_binary_not_equal_real64_t)(const real64_t *v1, const real64_t *v2, ajla_flat_option_t *r); _Bool (*REAL_binary_not_equal_real80_t)(const real80_t *v1, const real80_t *v2, ajla_flat_option_t *r);






 _Bool (*REAL_binary_less_real16_t)(const real16_t *v1, const real16_t *v2, ajla_flat_option_t *r); _Bool (*REAL_binary_less_real32_t)(const real32_t *v1, const real32_t *v2, ajla_flat_option_t *r); _Bool (*REAL_binary_less_real64_t)(const real64_t *v1, const real64_t *v2, ajla_flat_option_t *r); _Bool (*REAL_binary_less_real80_t)(const real80_t *v1, const real80_t *v2, ajla_flat_option_t *r);






 _Bool (*REAL_binary_less_equal_real16_t)(const real16_t *v1, const real16_t *v2, ajla_flat_option_t *r); _Bool (*REAL_binary_less_equal_real32_t)(const real32_t *v1, const real32_t *v2, ajla_flat_option_t *r); _Bool (*REAL_binary_less_equal_real64_t)(const real64_t *v1, const real64_t *v2, ajla_flat_option_t *r); _Bool (*REAL_binary_less_equal_real80_t)(const real80_t *v1, const real80_t *v2, ajla_flat_option_t *r);






 void (*REAL_unary_neg_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_neg_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_neg_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_neg_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_sqrt_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_sqrt_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_sqrt_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_sqrt_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_cbrt_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_cbrt_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_cbrt_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_cbrt_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_sin_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_sin_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_sin_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_sin_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_cos_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_cos_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_cos_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_cos_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_tan_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_tan_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_tan_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_tan_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_asin_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_asin_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_asin_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_asin_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_acos_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_acos_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_acos_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_acos_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_atan_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_atan_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_atan_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_atan_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_sinh_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_sinh_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_sinh_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_sinh_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_cosh_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_cosh_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_cosh_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_cosh_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_tanh_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_tanh_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_tanh_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_tanh_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_asinh_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_asinh_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_asinh_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_asinh_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_acosh_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_acosh_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_acosh_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_acosh_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_atanh_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_atanh_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_atanh_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_atanh_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_exp2_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_exp2_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_exp2_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_exp2_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_exp_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_exp_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_exp_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_exp_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_exp10_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_exp10_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_exp10_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_exp10_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_log2_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_log2_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_log2_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_log2_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_log_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_log_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_log_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_log_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_log10_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_log10_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_log10_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_log10_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_round_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_round_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_round_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_round_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_ceil_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_ceil_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_ceil_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_ceil_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_floor_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_floor_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_floor_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_floor_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_trunc_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_trunc_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_trunc_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_trunc_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_fract_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_fract_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_fract_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_fract_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_mantissa_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_mantissa_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_mantissa_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_mantissa_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_exponent_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_exponent_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_exponent_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_exponent_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_next_number_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_next_number_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_next_number_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_next_number_real80_t)(const real80_t *v1, real80_t *r);






 void (*REAL_unary_prev_number_real16_t)(const real16_t *v1, real16_t *r); void (*REAL_unary_prev_number_real32_t)(const real32_t *v1, real32_t *r); void (*REAL_unary_prev_number_real64_t)(const real64_t *v1, real64_t *r); void (*REAL_unary_prev_number_real80_t)(const real80_t *v1, real80_t *r);






 _Bool (*REAL_unary_to_int_real16_t)(const real16_t *val, int64_t *r); _Bool (*REAL_unary_to_int_real32_t)(const real32_t *val, int64_t *r); _Bool (*REAL_unary_to_int_real64_t)(const real64_t *val, int64_t *r); _Bool (*REAL_unary_to_int_real80_t)(const real80_t *val, int64_t *r);






 void (*REAL_unary_from_int_real16_t)(const int64_t *val, real16_t *r); void (*REAL_unary_from_int_real32_t)(const int64_t *val, real32_t *r); void (*REAL_unary_from_int_real64_t)(const int64_t *val, real64_t *r); void (*REAL_unary_from_int_real80_t)(const int64_t *val, real80_t *r);






 void (*REAL_unary_is_exception_real16_t)(const real16_t *v1, ajla_flat_option_t *r); void (*REAL_unary_is_exception_real32_t)(const real32_t *v1, ajla_flat_option_t *r); void (*REAL_unary_is_exception_real64_t)(const real64_t *v1, ajla_flat_option_t *r); void (*REAL_unary_is_exception_real80_t)(const real80_t *v1, ajla_flat_option_t *r);






};



extern struct cg_upcall_vector_s u_cg_upcall_vector;
# 39 "ipret.c" 2
# 183 "ipret.c"
 static inline __attribute__((__always_inline__)) _Bool FIXED_binary_add_int8_t (const uint8_t *op1, const uint8_t *op2, uint8_t *res){ *(uint8_t *)res = (*(const uint8_t *)op1) + (*(const uint8_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_subtract_int8_t (const uint8_t *op1, const uint8_t *op2, uint8_t *res){ *(uint8_t *)res = (*(const uint8_t *)op1) - (*(const uint8_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_multiply_int8_t (const uint8_t *op1, const uint8_t *op2, uint8_t *res){ *(uint8_t *)res = (*(const uint8_t *)op1) * (*(const uint8_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_and_int8_t (const uint8_t *op1, const uint8_t *op2, uint8_t *res){ *(uint8_t *)res = (*(const uint8_t *)op1) & (*(const uint8_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_or_int8_t (const uint8_t *op1, const uint8_t *op2, uint8_t *res){ *(uint8_t *)res = (*(const uint8_t *)op1) | (*(const uint8_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_xor_int8_t (const uint8_t *op1, const uint8_t *op2, uint8_t *res){ *(uint8_t *)res = (*(const uint8_t *)op1) ^ (*(const uint8_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_shl_int8_t (const uint8_t *op1, const uint8_t *op2, uint8_t *res){ *(uint8_t *)res = (*(const uint8_t *)op1) << ((*(const uint8_t *)op2) & (sizeof(uint8_t) * 8 - 1)); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_shr_int8_t (const uint8_t *op1, const uint8_t *op2, uint8_t *res){ *(uint8_t *)res = ((~(intmax_t)0x1234U >> 1) == ~(intmax_t)0x91aU) || (int8_t)(*(const uint8_t *)op1) >= 0 ? (uint8_t)((int8_t)(*(const uint8_t *)op1) >> ((*(const uint8_t *)op2) & (sizeof(uint8_t) * 8 - 1))) : ~(~(uint8_t)(*(const uint8_t *)op1) >> ((*(const uint8_t *)op2) & (sizeof(uint8_t) * 8 - 1))); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_ushr_int8_t (const uint8_t *op1, const uint8_t *op2, uint8_t *res){ *(uint8_t *)res = (*(const uint8_t *)op1) >> ((*(const uint8_t *)op2) & (sizeof(uint8_t) * 8 - 1)); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_equal_int8_t (const uint8_t *op1, const uint8_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (*(const uint8_t *)op1) == (*(const uint8_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_not_equal_int8_t (const uint8_t *op1, const uint8_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (*(const uint8_t *)op1) != (*(const uint8_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_less_int8_t (const uint8_t *op1, const uint8_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (int8_t)(*(const uint8_t *)op1) < (int8_t)(*(const uint8_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_less_equal_int8_t (const uint8_t *op1, const uint8_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (int8_t)(*(const uint8_t *)op1) <= (int8_t)(*(const uint8_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_uless_int8_t (const uint8_t *op1, const uint8_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (*(const uint8_t *)op1) < (*(const uint8_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_uless_equal_int8_t (const uint8_t *op1, const uint8_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (*(const uint8_t *)op1) <= (*(const uint8_t *)op2); return 1; } static inline __attribute__((__always_inline__)) void FIXED_unary_not_int8_t (const uint8_t *op1, uint8_t *res) { *(uint8_t *)res = ~(*(uint8_t *)op1); } static inline __attribute__((__always_inline__)) void FIXED_unary_neg_int8_t (const uint8_t *op1, uint8_t *res) { *(uint8_t *)res = -(*(uint8_t *)op1); } static inline __attribute__((__always_inline__)) void FIXED_unary_inc_int8_t (const uint8_t *op1, uint8_t *res) { *(uint8_t *)res = (*(uint8_t *)op1) + 1; } static inline __attribute__((__always_inline__)) void FIXED_unary_dec_int8_t (const uint8_t *op1, uint8_t *res) { *(uint8_t *)res = (*(uint8_t *)op1) - 1; } static inline __attribute__((__always_inline__)) ip_t fixed_ldc_int8_t (uint8_t *res, const code_t *ip, _Bool small){ if (small && 1 > 2) { *res = (uint8_t)(int16_t)ip[0]; return 1; } *res = (uint8_t)get_unaligned_8(ip); return (1 + 1) / 2; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_add_int16_t (const uint16_t *op1, const uint16_t *op2, uint16_t *res){ *(uint16_t *)res = (*(const uint16_t *)op1) + (*(const uint16_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_subtract_int16_t (const uint16_t *op1, const uint16_t *op2, uint16_t *res){ *(uint16_t *)res = (*(const uint16_t *)op1) - (*(const uint16_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_multiply_int16_t (const uint16_t *op1, const uint16_t *op2, uint16_t *res){ *(uint16_t *)res = (*(const uint16_t *)op1) * (*(const uint16_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_and_int16_t (const uint16_t *op1, const uint16_t *op2, uint16_t *res){ *(uint16_t *)res = (*(const uint16_t *)op1) & (*(const uint16_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_or_int16_t (const uint16_t *op1, const uint16_t *op2, uint16_t *res){ *(uint16_t *)res = (*(const uint16_t *)op1) | (*(const uint16_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_xor_int16_t (const uint16_t *op1, const uint16_t *op2, uint16_t *res){ *(uint16_t *)res = (*(const uint16_t *)op1) ^ (*(const uint16_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_shl_int16_t (const uint16_t *op1, const uint16_t *op2, uint16_t *res){ *(uint16_t *)res = (*(const uint16_t *)op1) << ((*(const uint16_t *)op2) & (sizeof(uint16_t) * 8 - 1)); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_shr_int16_t (const uint16_t *op1, const uint16_t *op2, uint16_t *res){ *(uint16_t *)res = ((~(intmax_t)0x1234U >> 1) == ~(intmax_t)0x91aU) || (int16_t)(*(const uint16_t *)op1) >= 0 ? (uint16_t)((int16_t)(*(const uint16_t *)op1) >> ((*(const uint16_t *)op2) & (sizeof(uint16_t) * 8 - 1))) : ~(~(uint16_t)(*(const uint16_t *)op1) >> ((*(const uint16_t *)op2) & (sizeof(uint16_t) * 8 - 1))); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_ushr_int16_t (const uint16_t *op1, const uint16_t *op2, uint16_t *res){ *(uint16_t *)res = (*(const uint16_t *)op1) >> ((*(const uint16_t *)op2) & (sizeof(uint16_t) * 8 - 1)); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_equal_int16_t (const uint16_t *op1, const uint16_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (*(const uint16_t *)op1) == (*(const uint16_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_not_equal_int16_t (const uint16_t *op1, const uint16_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (*(const uint16_t *)op1) != (*(const uint16_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_less_int16_t (const uint16_t *op1, const uint16_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (int16_t)(*(const uint16_t *)op1) < (int16_t)(*(const uint16_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_less_equal_int16_t (const uint16_t *op1, const uint16_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (int16_t)(*(const uint16_t *)op1) <= (int16_t)(*(const uint16_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_uless_int16_t (const uint16_t *op1, const uint16_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (*(const uint16_t *)op1) < (*(const uint16_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_uless_equal_int16_t (const uint16_t *op1, const uint16_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (*(const uint16_t *)op1) <= (*(const uint16_t *)op2); return 1; } static inline __attribute__((__always_inline__)) void FIXED_unary_not_int16_t (const uint16_t *op1, uint16_t *res) { *(uint16_t *)res = ~(*(uint16_t *)op1); } static inline __attribute__((__always_inline__)) void FIXED_unary_neg_int16_t (const uint16_t *op1, uint16_t *res) { *(uint16_t *)res = -(*(uint16_t *)op1); } static inline __attribute__((__always_inline__)) void FIXED_unary_inc_int16_t (const uint16_t *op1, uint16_t *res) { *(uint16_t *)res = (*(uint16_t *)op1) + 1; } static inline __attribute__((__always_inline__)) void FIXED_unary_dec_int16_t (const uint16_t *op1, uint16_t *res) { *(uint16_t *)res = (*(uint16_t *)op1) - 1; } static inline __attribute__((__always_inline__)) ip_t fixed_ldc_int16_t (uint16_t *res, const code_t *ip, _Bool small){ if (small && 2 > 2) { *res = (uint16_t)(int16_t)ip[0]; return 1; } *res = (uint16_t)get_unaligned_16(ip); return (2 + 1) / 2; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_add_int32_t (const uint32_t *op1, const uint32_t *op2, uint32_t *res){ *(uint32_t *)res = (*(const uint32_t *)op1) + (*(const uint32_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_subtract_int32_t (const uint32_t *op1, const uint32_t *op2, uint32_t *res){ *(uint32_t *)res = (*(const uint32_t *)op1) - (*(const uint32_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_multiply_int32_t (const uint32_t *op1, const uint32_t *op2, uint32_t *res){ *(uint32_t *)res = (*(const uint32_t *)op1) * (*(const uint32_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_and_int32_t (const uint32_t *op1, const uint32_t *op2, uint32_t *res){ *(uint32_t *)res = (*(const uint32_t *)op1) & (*(const uint32_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_or_int32_t (const uint32_t *op1, const uint32_t *op2, uint32_t *res){ *(uint32_t *)res = (*(const uint32_t *)op1) | (*(const uint32_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_xor_int32_t (const uint32_t *op1, const uint32_t *op2, uint32_t *res){ *(uint32_t *)res = (*(const uint32_t *)op1) ^ (*(const uint32_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_shl_int32_t (const uint32_t *op1, const uint32_t *op2, uint32_t *res){ *(uint32_t *)res = (*(const uint32_t *)op1) << ((*(const uint32_t *)op2) & (sizeof(uint32_t) * 8 - 1)); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_shr_int32_t (const uint32_t *op1, const uint32_t *op2, uint32_t *res){ *(uint32_t *)res = ((~(intmax_t)0x1234U >> 1) == ~(intmax_t)0x91aU) || (int32_t)(*(const uint32_t *)op1) >= 0 ? (uint32_t)((int32_t)(*(const uint32_t *)op1) >> ((*(const uint32_t *)op2) & (sizeof(uint32_t) * 8 - 1))) : ~(~(uint32_t)(*(const uint32_t *)op1) >> ((*(const uint32_t *)op2) & (sizeof(uint32_t) * 8 - 1))); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_ushr_int32_t (const uint32_t *op1, const uint32_t *op2, uint32_t *res){ *(uint32_t *)res = (*(const uint32_t *)op1) >> ((*(const uint32_t *)op2) & (sizeof(uint32_t) * 8 - 1)); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_equal_int32_t (const uint32_t *op1, const uint32_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (*(const uint32_t *)op1) == (*(const uint32_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_not_equal_int32_t (const uint32_t *op1, const uint32_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (*(const uint32_t *)op1) != (*(const uint32_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_less_int32_t (const uint32_t *op1, const uint32_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (int32_t)(*(const uint32_t *)op1) < (int32_t)(*(const uint32_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_less_equal_int32_t (const uint32_t *op1, const uint32_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (int32_t)(*(const uint32_t *)op1) <= (int32_t)(*(const uint32_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_uless_int32_t (const uint32_t *op1, const uint32_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (*(const uint32_t *)op1) < (*(const uint32_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_uless_equal_int32_t (const uint32_t *op1, const uint32_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (*(const uint32_t *)op1) <= (*(const uint32_t *)op2); return 1; } static inline __attribute__((__always_inline__)) void FIXED_unary_not_int32_t (const uint32_t *op1, uint32_t *res) { *(uint32_t *)res = ~(*(uint32_t *)op1); } static inline __attribute__((__always_inline__)) void FIXED_unary_neg_int32_t (const uint32_t *op1, uint32_t *res) { *(uint32_t *)res = -(*(uint32_t *)op1); } static inline __attribute__((__always_inline__)) void FIXED_unary_inc_int32_t (const uint32_t *op1, uint32_t *res) { *(uint32_t *)res = (*(uint32_t *)op1) + 1; } static inline __attribute__((__always_inline__)) void FIXED_unary_dec_int32_t (const uint32_t *op1, uint32_t *res) { *(uint32_t *)res = (*(uint32_t *)op1) - 1; } static inline __attribute__((__always_inline__)) ip_t fixed_ldc_int32_t (uint32_t *res, const code_t *ip, _Bool small){ if (small && 4 > 2) { *res = (uint32_t)(int16_t)ip[0]; return 1; } *res = (uint32_t)get_unaligned_32(ip); return (4 + 1) / 2; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_add_int64_t (const uint64_t *op1, const uint64_t *op2, uint64_t *res){ *(uint64_t *)res = (*(const uint64_t *)op1) + (*(const uint64_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_subtract_int64_t (const uint64_t *op1, const uint64_t *op2, uint64_t *res){ *(uint64_t *)res = (*(const uint64_t *)op1) - (*(const uint64_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_multiply_int64_t (const uint64_t *op1, const uint64_t *op2, uint64_t *res){ *(uint64_t *)res = (*(const uint64_t *)op1) * (*(const uint64_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_and_int64_t (const uint64_t *op1, const uint64_t *op2, uint64_t *res){ *(uint64_t *)res = (*(const uint64_t *)op1) & (*(const uint64_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_or_int64_t (const uint64_t *op1, const uint64_t *op2, uint64_t *res){ *(uint64_t *)res = (*(const uint64_t *)op1) | (*(const uint64_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_xor_int64_t (const uint64_t *op1, const uint64_t *op2, uint64_t *res){ *(uint64_t *)res = (*(const uint64_t *)op1) ^ (*(const uint64_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_shl_int64_t (const uint64_t *op1, const uint64_t *op2, uint64_t *res){ *(uint64_t *)res = (*(const uint64_t *)op1) << ((*(const uint64_t *)op2) & (sizeof(uint64_t) * 8 - 1)); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_shr_int64_t (const uint64_t *op1, const uint64_t *op2, uint64_t *res){ *(uint64_t *)res = ((~(intmax_t)0x1234U >> 1) == ~(intmax_t)0x91aU) || (int64_t)(*(const uint64_t *)op1) >= 0 ? (uint64_t)((int64_t)(*(const uint64_t *)op1) >> ((*(const uint64_t *)op2) & (sizeof(uint64_t) * 8 - 1))) : ~(~(uint64_t)(*(const uint64_t *)op1) >> ((*(const uint64_t *)op2) & (sizeof(uint64_t) * 8 - 1))); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_ushr_int64_t (const uint64_t *op1, const uint64_t *op2, uint64_t *res){ *(uint64_t *)res = (*(const uint64_t *)op1) >> ((*(const uint64_t *)op2) & (sizeof(uint64_t) * 8 - 1)); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_equal_int64_t (const uint64_t *op1, const uint64_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (*(const uint64_t *)op1) == (*(const uint64_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_not_equal_int64_t (const uint64_t *op1, const uint64_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (*(const uint64_t *)op1) != (*(const uint64_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_less_int64_t (const uint64_t *op1, const uint64_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (int64_t)(*(const uint64_t *)op1) < (int64_t)(*(const uint64_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_less_equal_int64_t (const uint64_t *op1, const uint64_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (int64_t)(*(const uint64_t *)op1) <= (int64_t)(*(const uint64_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_uless_int64_t (const uint64_t *op1, const uint64_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (*(const uint64_t *)op1) < (*(const uint64_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_uless_equal_int64_t (const uint64_t *op1, const uint64_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (*(const uint64_t *)op1) <= (*(const uint64_t *)op2); return 1; } static inline __attribute__((__always_inline__)) void FIXED_unary_not_int64_t (const uint64_t *op1, uint64_t *res) { *(uint64_t *)res = ~(*(uint64_t *)op1); } static inline __attribute__((__always_inline__)) void FIXED_unary_neg_int64_t (const uint64_t *op1, uint64_t *res) { *(uint64_t *)res = -(*(uint64_t *)op1); } static inline __attribute__((__always_inline__)) void FIXED_unary_inc_int64_t (const uint64_t *op1, uint64_t *res) { *(uint64_t *)res = (*(uint64_t *)op1) + 1; } static inline __attribute__((__always_inline__)) void FIXED_unary_dec_int64_t (const uint64_t *op1, uint64_t *res) { *(uint64_t *)res = (*(uint64_t *)op1) - 1; } static inline __attribute__((__always_inline__)) ip_t fixed_ldc_int64_t (uint64_t *res, const code_t *ip, _Bool small){ if (small && 8 > 2) { *res = (uint64_t)(int16_t)ip[0]; return 1; } *res = (uint64_t)get_unaligned_64(ip); return (8 + 1) / 2; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_add_int128_t (const uint128_t *op1, const uint128_t *op2, uint128_t *res){ *(uint128_t *)res = (*(const uint128_t *)op1) + (*(const uint128_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_subtract_int128_t (const uint128_t *op1, const uint128_t *op2, uint128_t *res){ *(uint128_t *)res = (*(const uint128_t *)op1) - (*(const uint128_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_multiply_int128_t (const uint128_t *op1, const uint128_t *op2, uint128_t *res){ *(uint128_t *)res = (*(const uint128_t *)op1) * (*(const uint128_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_and_int128_t (const uint128_t *op1, const uint128_t *op2, uint128_t *res){ *(uint128_t *)res = (*(const uint128_t *)op1) & (*(const uint128_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_or_int128_t (const uint128_t *op1, const uint128_t *op2, uint128_t *res){ *(uint128_t *)res = (*(const uint128_t *)op1) | (*(const uint128_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_xor_int128_t (const uint128_t *op1, const uint128_t *op2, uint128_t *res){ *(uint128_t *)res = (*(const uint128_t *)op1) ^ (*(const uint128_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_shl_int128_t (const uint128_t *op1, const uint128_t *op2, uint128_t *res){ *(uint128_t *)res = (*(const uint128_t *)op1) << ((*(const uint128_t *)op2) & (sizeof(uint128_t) * 8 - 1)); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_shr_int128_t (const uint128_t *op1, const uint128_t *op2, uint128_t *res){ *(uint128_t *)res = ((~(intmax_t)0x1234U >> 1) == ~(intmax_t)0x91aU) || (int128_t)(*(const uint128_t *)op1) >= 0 ? (uint128_t)((int128_t)(*(const uint128_t *)op1) >> ((*(const uint128_t *)op2) & (sizeof(uint128_t) * 8 - 1))) : ~(~(uint128_t)(*(const uint128_t *)op1) >> ((*(const uint128_t *)op2) & (sizeof(uint128_t) * 8 - 1))); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_ushr_int128_t (const uint128_t *op1, const uint128_t *op2, uint128_t *res){ *(uint128_t *)res = (*(const uint128_t *)op1) >> ((*(const uint128_t *)op2) & (sizeof(uint128_t) * 8 - 1)); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_equal_int128_t (const uint128_t *op1, const uint128_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (*(const uint128_t *)op1) == (*(const uint128_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_not_equal_int128_t (const uint128_t *op1, const uint128_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (*(const uint128_t *)op1) != (*(const uint128_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_less_int128_t (const uint128_t *op1, const uint128_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (int128_t)(*(const uint128_t *)op1) < (int128_t)(*(const uint128_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_less_equal_int128_t (const uint128_t *op1, const uint128_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (int128_t)(*(const uint128_t *)op1) <= (int128_t)(*(const uint128_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_uless_int128_t (const uint128_t *op1, const uint128_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (*(const uint128_t *)op1) < (*(const uint128_t *)op2); return 1; } static inline __attribute__((__always_inline__)) _Bool FIXED_binary_uless_equal_int128_t (const uint128_t *op1, const uint128_t *op2, ajla_flat_option_t *res){ *(ajla_flat_option_t *)res = (*(const uint128_t *)op1) <= (*(const uint128_t *)op2); return 1; } static inline __attribute__((__always_inline__)) void FIXED_unary_not_int128_t (const uint128_t *op1, uint128_t *res) { *(uint128_t *)res = ~(*(uint128_t *)op1); } static inline __attribute__((__always_inline__)) void FIXED_unary_neg_int128_t (const uint128_t *op1, uint128_t *res) { *(uint128_t *)res = -(*(uint128_t *)op1); } static inline __attribute__((__always_inline__)) void FIXED_unary_inc_int128_t (const uint128_t *op1, uint128_t *res) { *(uint128_t *)res = (*(uint128_t *)op1) + 1; } static inline __attribute__((__always_inline__)) void FIXED_unary_dec_int128_t (const uint128_t *op1, uint128_t *res) { *(uint128_t *)res = (*(uint128_t *)op1) - 1; } static inline __attribute__((__always_inline__)) ip_t fixed_ldc_int128_t (uint128_t *res, const code_t *ip, _Bool small){ if (small && 16 > 2) { *res = (uint128_t)(int16_t)ip[0]; return 1; } *res = (uint128_t)get_unaligned_128(ip); return (16 + 1) / 2; }
# 223 "ipret.c"
static inline __attribute__((__always_inline__)) _Bool INT_binary_and_int8_t(const void *op1, const void *op2, void *res){ *((int8_t *)(void *)(res)) = *((const int8_t *)(void *)(op1)) & *((const int8_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_or_int8_t(const void *op1, const void *op2, void *res){ *((int8_t *)(void *)(res)) = *((const int8_t *)(void *)(op1)) | *((const int8_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_xor_int8_t(const void *op1, const void *op2, void *res){ *((int8_t *)(void *)(res)) = *((const int8_t *)(void *)(op1)) ^ *((const int8_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_equal_int8_t(const void *op1, const void *op2, ajla_flat_option_t *res){ *res = *((const int8_t *)(void *)(op1)) == *((const int8_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_not_equal_int8_t(const void *op1, const void *op2, ajla_flat_option_t *res){ *res = *((const int8_t *)(void *)(op1)) != *((const int8_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_less_int8_t(const void *op1, const void *op2, ajla_flat_option_t *res){ *res = *((const int8_t *)(void *)(op1)) < *((const int8_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_less_equal_int8_t(const void *op1, const void *op2, ajla_flat_option_t *res){ *res = *((const int8_t *)(void *)(op1)) <= *((const int8_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) ip_t int_ldc_int8_t (int8_t *res, const code_t *ip, _Bool small){ return fixed_ldc_int8_t(((uint8_t *)(void *)(res)), ip, small); } static inline __attribute__((__always_inline__)) _Bool INT_binary_and_int16_t(const void *op1, const void *op2, void *res){ *((int16_t *)(void *)(res)) = *((const int16_t *)(void *)(op1)) & *((const int16_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_or_int16_t(const void *op1, const void *op2, void *res){ *((int16_t *)(void *)(res)) = *((const int16_t *)(void *)(op1)) | *((const int16_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_xor_int16_t(const void *op1, const void *op2, void *res){ *((int16_t *)(void *)(res)) = *((const int16_t *)(void *)(op1)) ^ *((const int16_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_equal_int16_t(const void *op1, const void *op2, ajla_flat_option_t *res){ *res = *((const int16_t *)(void *)(op1)) == *((const int16_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_not_equal_int16_t(const void *op1, const void *op2, ajla_flat_option_t *res){ *res = *((const int16_t *)(void *)(op1)) != *((const int16_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_less_int16_t(const void *op1, const void *op2, ajla_flat_option_t *res){ *res = *((const int16_t *)(void *)(op1)) < *((const int16_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_less_equal_int16_t(const void *op1, const void *op2, ajla_flat_option_t *res){ *res = *((const int16_t *)(void *)(op1)) <= *((const int16_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) ip_t int_ldc_int16_t (int16_t *res, const code_t *ip, _Bool small){ return fixed_ldc_int16_t(((uint16_t *)(void *)(res)), ip, small); } static inline __attribute__((__always_inline__)) _Bool INT_binary_and_int32_t(const void *op1, const void *op2, void *res){ *((int32_t *)(void *)(res)) = *((const int32_t *)(void *)(op1)) & *((const int32_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_or_int32_t(const void *op1, const void *op2, void *res){ *((int32_t *)(void *)(res)) = *((const int32_t *)(void *)(op1)) | *((const int32_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_xor_int32_t(const void *op1, const void *op2, void *res){ *((int32_t *)(void *)(res)) = *((const int32_t *)(void *)(op1)) ^ *((const int32_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_equal_int32_t(const void *op1, const void *op2, ajla_flat_option_t *res){ *res = *((const int32_t *)(void *)(op1)) == *((const int32_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_not_equal_int32_t(const void *op1, const void *op2, ajla_flat_option_t *res){ *res = *((const int32_t *)(void *)(op1)) != *((const int32_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_less_int32_t(const void *op1, const void *op2, ajla_flat_option_t *res){ *res = *((const int32_t *)(void *)(op1)) < *((const int32_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_less_equal_int32_t(const void *op1, const void *op2, ajla_flat_option_t *res){ *res = *((const int32_t *)(void *)(op1)) <= *((const int32_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) ip_t int_ldc_int32_t (int32_t *res, const code_t *ip, _Bool small){ return fixed_ldc_int32_t(((uint32_t *)(void *)(res)), ip, small); } static inline __attribute__((__always_inline__)) _Bool INT_binary_and_int64_t(const void *op1, const void *op2, void *res){ *((int64_t *)(void *)(res)) = *((const int64_t *)(void *)(op1)) & *((const int64_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_or_int64_t(const void *op1, const void *op2, void *res){ *((int64_t *)(void *)(res)) = *((const int64_t *)(void *)(op1)) | *((const int64_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_xor_int64_t(const void *op1, const void *op2, void *res){ *((int64_t *)(void *)(res)) = *((const int64_t *)(void *)(op1)) ^ *((const int64_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_equal_int64_t(const void *op1, const void *op2, ajla_flat_option_t *res){ *res = *((const int64_t *)(void *)(op1)) == *((const int64_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_not_equal_int64_t(const void *op1, const void *op2, ajla_flat_option_t *res){ *res = *((const int64_t *)(void *)(op1)) != *((const int64_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_less_int64_t(const void *op1, const void *op2, ajla_flat_option_t *res){ *res = *((const int64_t *)(void *)(op1)) < *((const int64_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_less_equal_int64_t(const void *op1, const void *op2, ajla_flat_option_t *res){ *res = *((const int64_t *)(void *)(op1)) <= *((const int64_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) ip_t int_ldc_int64_t (int64_t *res, const code_t *ip, _Bool small){ return fixed_ldc_int64_t(((uint64_t *)(void *)(res)), ip, small); } static inline __attribute__((__always_inline__)) _Bool INT_binary_and_int128_t(const void *op1, const void *op2, void *res){ *((int128_t *)(void *)(res)) = *((const int128_t *)(void *)(op1)) & *((const int128_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_or_int128_t(const void *op1, const void *op2, void *res){ *((int128_t *)(void *)(res)) = *((const int128_t *)(void *)(op1)) | *((const int128_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_xor_int128_t(const void *op1, const void *op2, void *res){ *((int128_t *)(void *)(res)) = *((const int128_t *)(void *)(op1)) ^ *((const int128_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_equal_int128_t(const void *op1, const void *op2, ajla_flat_option_t *res){ *res = *((const int128_t *)(void *)(op1)) == *((const int128_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_not_equal_int128_t(const void *op1, const void *op2, ajla_flat_option_t *res){ *res = *((const int128_t *)(void *)(op1)) != *((const int128_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_less_int128_t(const void *op1, const void *op2, ajla_flat_option_t *res){ *res = *((const int128_t *)(void *)(op1)) < *((const int128_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) _Bool INT_binary_less_equal_int128_t(const void *op1, const void *op2, ajla_flat_option_t *res){ *res = *((const int128_t *)(void *)(op1)) <= *((const int128_t *)(void *)(op2)); return 1; } static inline __attribute__((__always_inline__)) ip_t int_ldc_int128_t (int128_t *res, const code_t *ip, _Bool small){ return fixed_ldc_int128_t(((uint128_t *)(void *)(res)), ip, small); }
# 238 "ipret.c"
static inline __attribute__((__always_inline__)) _Bool do_nextafter_real16_t(real16_t __attribute__((__unused__)) x, int __attribute__((__unused__)) dir, real16_t __attribute__((__unused__)) *res)
{
 return 0;
}



static inline __attribute__((__always_inline__)) _Bool do_nextafter_real32_t(real32_t __attribute__((__unused__)) x, int __attribute__((__unused__)) dir, real32_t __attribute__((__unused__)) *res)
{

 *res = nextafterf(x, (__builtin_huge_valf ()) * dir);
 return 1;



}



static inline __attribute__((__always_inline__)) _Bool do_nextafter_real64_t(real64_t __attribute__((__unused__)) x, int __attribute__((__unused__)) dir, real64_t __attribute__((__unused__)) *res)
{

 *res = nextafter(x, (__builtin_huge_val ()) * dir);
 return 1;



}



static inline __attribute__((__always_inline__)) _Bool do_nextafter_real80_t(real80_t __attribute__((__unused__)) x, int dir, real80_t __attribute__((__unused__)) *res)
{

 *res = nextafterl(x, (__builtin_huge_vall ()) * dir);
 return 1;



}
# 554 "ipret.c"
 static inline __attribute__((__always_inline__)) _Bool REAL_binary_add_real16_t (const real16_t *op1, const real16_t *op2, real16_t *res){ *res = (float_to_half(((half_to_float(*op1))) + ((half_to_float(*op2))))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_subtract_real16_t (const real16_t *op1, const real16_t *op2, real16_t *res){ *res = (float_to_half(((half_to_float(*op1))) - ((half_to_float(*op2))))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_multiply_real16_t (const real16_t *op1, const real16_t *op2, real16_t *res){ *res = (float_to_half(((half_to_float(*op1))) * ((half_to_float(*op2))))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_divide_real16_t (const real16_t *op1, const real16_t *op2, real16_t *res){ *res = (float_to_half(((half_to_float(*op1))) / ((half_to_float(*op2))))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_modulo_real16_t (const real16_t *op1, const real16_t *op2, real16_t *res){ *res = (float_to_half(fmodf(((half_to_float(*op1))), ((half_to_float(*op2)))))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_atan2_real16_t (const real16_t *op1, const real16_t *op2, real16_t *res){ *res = (float_to_half(atan2f(((half_to_float(*op1))), ((half_to_float(*op2)))))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_equal_real16_t (const real16_t *op1, const real16_t *op2, ajla_flat_option_t *res){ real32_t o1 = (half_to_float(*op1)); real32_t o2 = (half_to_float(*op2)); if (((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))) return 0; *res = o1 == o2; return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_not_equal_real16_t (const real16_t *op1, const real16_t *op2, ajla_flat_option_t *res){ real32_t o1 = (half_to_float(*op1)); real32_t o2 = (half_to_float(*op2)); if (((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))) return 0; *res = __builtin_islessgreater(o1, o2); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_less_real16_t (const real16_t *op1, const real16_t *op2, ajla_flat_option_t *res){ real32_t o1 = (half_to_float(*op1)); real32_t o2 = (half_to_float(*op2)); if (((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))) return 0; *res = __builtin_isless(o1, o2); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_less_equal_real16_t (const real16_t *op1, const real16_t *op2, ajla_flat_option_t *res){ real32_t o1 = (half_to_float(*op1)); real32_t o2 = (half_to_float(*op2)); if (((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))) return 0; *res = __builtin_islessequal(o1, o2); return 1; } static inline __attribute__((__always_inline__)) void REAL_unary_neg_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!0) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(-((half_to_float(*op1))))); } static inline __attribute__((__always_inline__)) void REAL_unary_sqrt_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(sqrtf(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) void REAL_unary_cbrt_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(cbrtf(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) void REAL_unary_sin_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(sinf(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) void REAL_unary_cos_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(cosf(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) void REAL_unary_tan_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(tanf(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) void REAL_unary_asin_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(asinf(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) void REAL_unary_acos_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(acosf(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) void REAL_unary_atan_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(atanf(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) void REAL_unary_sinh_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(sinhf(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) void REAL_unary_cosh_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(coshf(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) void REAL_unary_tanh_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(tanhf(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) void REAL_unary_asinh_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(asinhf(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) void REAL_unary_acosh_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(acoshf(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) void REAL_unary_atanh_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(atanhf(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) void REAL_unary_exp2_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(exp2f(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) void REAL_unary_exp_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(expf(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) void REAL_unary_exp10_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(exp10f(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) void REAL_unary_log2_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(log2f(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) void REAL_unary_log_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(logf(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) void REAL_unary_log10_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(log10f(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) void REAL_unary_round_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(rintf(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) void REAL_unary_ceil_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(ceilf(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) void REAL_unary_floor_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(floorf(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) void REAL_unary_trunc_real16_t (const real16_t *op1, real16_t *res) { if (!0 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (float_to_half(truncf(((half_to_float(*op1)))))); } static inline __attribute__((__always_inline__)) _Bool REAL_binary_power_real16_t (const real16_t *op1, const real16_t *op2, real16_t *res){ real32_t o1 = (half_to_float(*op1)); real32_t o2 = (half_to_float(*op2)); real32_t r; if ((__builtin_expect((int)(((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))), 0))) return 0; r = powf(o1, o2); *res = (float_to_half(r)); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_ldexp_real16_t (const real16_t *op1, const real16_t *op2, real16_t *res){ real32_t m; real32_t o1 = (half_to_float(*op1)); real32_t o2 = (half_to_float(*op2)); if ((__builtin_expect((int)(((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))), 0))) return 0; if ((__builtin_expect((int)(o2 >= (real32_t)((int)(-((int)1 << (8 * sizeof(int) - 2)) * 2))), 1)) && (__builtin_expect((int)(o2 <= (real32_t)(~((int)(-((int)1 << (8 * sizeof(int) - 2)) * 2)))), 1)) && (__builtin_expect((int)(o2 == (int)o2), 1))) { *res = (float_to_half(ldexpf(o1, (int)o2))); } else { m = exp2f(o2); m *= o1; *res = (float_to_half(m)); } return 1; } static inline __attribute__((__always_inline__)) void REAL_unary_fract_real16_t (const real16_t *op1, real16_t *res) { real32_t m = (half_to_float(*op1)); union { real32_t i; float f; } u; if (0) { if ((__builtin_expect((int)(!isnanf(m)), 1)) && (__builtin_expect((int)(!(((__builtin_huge_val ()) == (__builtin_huge_val ()) / 2) && fabsf(m) < (__builtin_huge_val ()))), 0))) { *res = (float_to_half(m >= 0 ? 0. : -0.)); return; } } *res = (float_to_half(modff(m, (void *)&u))); } static inline __attribute__((__always_inline__)) void REAL_unary_mantissa_real16_t (const real16_t *op1, real16_t *res) { int i; *res = (float_to_half(frexpf((half_to_float(*op1)), &i))); } static inline __attribute__((__always_inline__)) void REAL_unary_exponent_real16_t (const real16_t *op1, real16_t *res) { int i; real32_t m = frexpf((half_to_float(*op1)), &i); if ((__builtin_expect((int)(isnanf(m)), 0))) { *res = (float_to_half(m)); return; } if ((__builtin_expect((int)(!(((__builtin_huge_val ()) == (__builtin_huge_val ()) / 2) && fabsf(m) < (__builtin_huge_val ()))), 0))) { *res = (float_to_half((real32_t)0.)); return; } *res = (float_to_half((real32_t)i)); } static inline __attribute__((__always_inline__)) real16_t REAL_unary_next_prev_number_real16_t (real16_t op1, int dir) { int ex, bit; volatile real32_t m, mm, n1; volatile real16_t res, o; if ((__builtin_expect((int)((((op1) & 0x7fff) > 0x7c00)), 0))) return op1; n1 = (half_to_float(op1)); if ((__builtin_expect((int)(!(((op1) & 0x7fff) < 0x7c00)), 0))) { if ((n1 >= 0) == (dir >= 0)) return op1; m = ldexpf(1, 11) - 1; while (1) { mm = m * 2; res = (float_to_half(mm)); if ((__builtin_expect((int)(!(((res) & 0x7fff) < 0x7c00)), 0))) break; m = mm; } return (float_to_half(m * -dir)); } if ((__builtin_expect((int)(!n1), 0))) { res = (float_to_half(1)); o = (float_to_half(1)); while (1) { o = (float_to_half((half_to_float(o)) * 0.5)); m = (half_to_float(o)); if (m == 0) break; res = o; } return (float_to_half((half_to_float(res)) * dir)); } m = frexpf(n1, &ex); bit = 11; again: mm = m + ldexpf(dir, -bit); o = (float_to_half(ldexpf(mm, ex))); res = o; if ((half_to_float(res)) == n1) { bit--; goto again; } return res; } static inline __attribute__((__always_inline__)) void REAL_unary_next_number_real16_t (const real16_t *op1, real16_t *res) { if (do_nextafter_real16_t(*op1, 1, res)) return; *res = REAL_unary_next_prev_number_real16_t(*op1, 1); } static inline __attribute__((__always_inline__)) void REAL_unary_prev_number_real16_t (const real16_t *op1, real16_t *res) { if (do_nextafter_real16_t(*op1, -1, res)) return; *res = REAL_unary_next_prev_number_real16_t(*op1, -1); } static inline __attribute__((__always_inline__)) _Bool REAL_unary_to_int_real16_t(const real16_t *val, int64_t *r){ real32_t val1; val1 = (half_to_float(*val)); if ((__builtin_expect((int)(val1 > (real32_t)((int64_t)(-((int64_t)1 << (8 * sizeof(int64_t) - 2)) * 2))), 1)) && (__builtin_expect((int)(val1 < (real32_t)(~((int64_t)(-((int64_t)1 << (8 * sizeof(int64_t) - 2)) * 2)))), 1))) { *r = val1; return 1; } return 0; } static inline __attribute__((__always_inline__)) void REAL_unary_from_int_real16_t(const int64_t *val, real16_t *r){ *r = (float_to_half(*val)); } static inline __attribute__((__always_inline__)) void REAL_unary_is_exception_real16_t (const real16_t *op1, ajla_flat_option_t *res){ *res = (((*op1) & 0x7fff) > 0x7c00); }static inline __attribute__((__always_inline__)) size_t fixed_ldc_real16_t (real16_t *res, const code_t *ip, _Bool __attribute__((__unused__)) shrt){ memcpy(res, ip, sizeof(real16_t)); return (((sizeof(real16_t)) + (sizeof(code_t)) - 1) & ~((sizeof(code_t)) - 1 + 0 * (sizeof(real16_t)))) / sizeof(code_t);} static inline __attribute__((__always_inline__)) _Bool REAL_binary_add_real32_t (const real32_t *op1, const real32_t *op2, real32_t *res){ *res = (((*op1)) + ((*op2))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_subtract_real32_t (const real32_t *op1, const real32_t *op2, real32_t *res){ *res = (((*op1)) - ((*op2))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_multiply_real32_t (const real32_t *op1, const real32_t *op2, real32_t *res){ *res = (((*op1)) * ((*op2))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_divide_real32_t (const real32_t *op1, const real32_t *op2, real32_t *res){ *res = (((*op1)) / ((*op2))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_modulo_real32_t (const real32_t *op1, const real32_t *op2, real32_t *res){ *res = (fmodf(((*op1)), ((*op2)))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_atan2_real32_t (const real32_t *op1, const real32_t *op2, real32_t *res){ *res = (atan2f(((*op1)), ((*op2)))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_equal_real32_t (const real32_t *op1, const real32_t *op2, ajla_flat_option_t *res){ real32_t o1 = (*op1); real32_t o2 = (*op2); if (((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))) return 0; *res = o1 == o2; return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_not_equal_real32_t (const real32_t *op1, const real32_t *op2, ajla_flat_option_t *res){ real32_t o1 = (*op1); real32_t o2 = (*op2); if (((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))) return 0; *res = __builtin_islessgreater(o1, o2); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_less_real32_t (const real32_t *op1, const real32_t *op2, ajla_flat_option_t *res){ real32_t o1 = (*op1); real32_t o2 = (*op2); if (((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))) return 0; *res = __builtin_isless(o1, o2); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_less_equal_real32_t (const real32_t *op1, const real32_t *op2, ajla_flat_option_t *res){ real32_t o1 = (*op1); real32_t o2 = (*op2); if (((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))) return 0; *res = __builtin_islessequal(o1, o2); return 1; } static inline __attribute__((__always_inline__)) void REAL_unary_neg_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!0) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (-((*op1))); } static inline __attribute__((__always_inline__)) void REAL_unary_sqrt_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (sqrtf(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_cbrt_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (cbrtf(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_sin_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (sinf(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_cos_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (cosf(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_tan_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (tanf(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_asin_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (asinf(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_acos_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (acosf(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_atan_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (atanf(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_sinh_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (sinhf(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_cosh_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (coshf(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_tanh_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (tanhf(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_asinh_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (asinhf(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_acosh_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (acoshf(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_atanh_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (atanhf(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_exp2_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (exp2f(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_exp_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (expf(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_exp10_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (exp10f(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_log2_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (log2f(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_log_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (logf(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_log10_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (log10f(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_round_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (rintf(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_ceil_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (ceilf(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_floor_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (floorf(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_trunc_real32_t (const real32_t *op1, real32_t *res) { if (!1 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (truncf(((*op1)))); } static inline __attribute__((__always_inline__)) _Bool REAL_binary_power_real32_t (const real32_t *op1, const real32_t *op2, real32_t *res){ real32_t o1 = (*op1); real32_t o2 = (*op2); real32_t r; if ((__builtin_expect((int)(((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))), 0))) return 0; r = powf(o1, o2); *res = (r); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_ldexp_real32_t (const real32_t *op1, const real32_t *op2, real32_t *res){ real32_t m; real32_t o1 = (*op1); real32_t o2 = (*op2); if ((__builtin_expect((int)(((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))), 0))) return 0; if ((__builtin_expect((int)(o2 >= (real32_t)((int)(-((int)1 << (8 * sizeof(int) - 2)) * 2))), 1)) && (__builtin_expect((int)(o2 <= (real32_t)(~((int)(-((int)1 << (8 * sizeof(int) - 2)) * 2)))), 1)) && (__builtin_expect((int)(o2 == (int)o2), 1))) { *res = (ldexpf(o1, (int)o2)); } else { m = exp2f(o2); m *= o1; *res = (m); } return 1; } static inline __attribute__((__always_inline__)) void REAL_unary_fract_real32_t (const real32_t *op1, real32_t *res) { real32_t m = (*op1); union { real32_t i; float f; } u; if (0) { if ((__builtin_expect((int)(!isnanf(m)), 1)) && (__builtin_expect((int)(!(((__builtin_huge_val ()) == (__builtin_huge_val ()) / 2) && fabsf(m) < (__builtin_huge_val ()))), 0))) { *res = (m >= 0 ? 0. : -0.); return; } } *res = (modff(m, (void *)&u)); } static inline __attribute__((__always_inline__)) void REAL_unary_mantissa_real32_t (const real32_t *op1, real32_t *res) { int i; *res = (frexpf((*op1), &i)); } static inline __attribute__((__always_inline__)) void REAL_unary_exponent_real32_t (const real32_t *op1, real32_t *res) { int i; real32_t m = frexpf((*op1), &i); if ((__builtin_expect((int)(isnanf(m)), 0))) { *res = (m); return; } if ((__builtin_expect((int)(!(((__builtin_huge_val ()) == (__builtin_huge_val ()) / 2) && fabsf(m) < (__builtin_huge_val ()))), 0))) { *res = ((real32_t)0.); return; } *res = ((real32_t)i); } static inline __attribute__((__always_inline__)) real32_t REAL_unary_next_prev_number_real32_t (real32_t op1, int dir) { int ex, bit; volatile real32_t m, mm, n1; volatile real32_t res, o; if ((__builtin_expect((int)(isnanf(op1)), 0))) return op1; n1 = (op1); if ((__builtin_expect((int)(!(((__builtin_huge_val ()) == (__builtin_huge_val ()) / 2) && fabsf(op1) < (__builtin_huge_val ()))), 0))) { if ((n1 >= 0) == (dir >= 0)) return op1; m = ldexpf(1, 24) - 1; while (1) { mm = m * 2; res = (mm); if ((__builtin_expect((int)(!(((__builtin_huge_val ()) == (__builtin_huge_val ()) / 2) && fabsf(res) < (__builtin_huge_val ()))), 0))) break; m = mm; } return (m * -dir); } if ((__builtin_expect((int)(!n1), 0))) { res = (1); o = (1); while (1) { o = ((o) * 0.5); m = (o); if (m == 0) break; res = o; } return ((res) * dir); } m = frexpf(n1, &ex); bit = 24; again: mm = m + ldexpf(dir, -bit); o = (ldexpf(mm, ex)); res = o; if ((res) == n1) { bit--; goto again; } return res; } static inline __attribute__((__always_inline__)) void REAL_unary_next_number_real32_t (const real32_t *op1, real32_t *res) { if (do_nextafter_real32_t(*op1, 1, res)) return; *res = REAL_unary_next_prev_number_real32_t(*op1, 1); } static inline __attribute__((__always_inline__)) void REAL_unary_prev_number_real32_t (const real32_t *op1, real32_t *res) { if (do_nextafter_real32_t(*op1, -1, res)) return; *res = REAL_unary_next_prev_number_real32_t(*op1, -1); } static inline __attribute__((__always_inline__)) _Bool REAL_unary_to_int_real32_t(const real32_t *val, int64_t *r){ real32_t val1; val1 = (*val); if ((__builtin_expect((int)(val1 > (real32_t)((int64_t)(-((int64_t)1 << (8 * sizeof(int64_t) - 2)) * 2))), 1)) && (__builtin_expect((int)(val1 < (real32_t)(~((int64_t)(-((int64_t)1 << (8 * sizeof(int64_t) - 2)) * 2)))), 1))) { *r = val1; return 1; } return 0; } static inline __attribute__((__always_inline__)) void REAL_unary_from_int_real32_t(const int64_t *val, real32_t *r){ *r = (*val); } static inline __attribute__((__always_inline__)) void REAL_unary_is_exception_real32_t (const real32_t *op1, ajla_flat_option_t *res){ *res = isnanf(*op1); }static inline __attribute__((__always_inline__)) size_t fixed_ldc_real32_t (real32_t *res, const code_t *ip, _Bool __attribute__((__unused__)) shrt){ memcpy(res, ip, sizeof(real32_t)); return (((sizeof(real32_t)) + (sizeof(code_t)) - 1) & ~((sizeof(code_t)) - 1 + 0 * (sizeof(real32_t)))) / sizeof(code_t);} static inline __attribute__((__always_inline__)) _Bool REAL_binary_add_real64_t (const real64_t *op1, const real64_t *op2, real64_t *res){ *res = (((*op1)) + ((*op2))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_subtract_real64_t (const real64_t *op1, const real64_t *op2, real64_t *res){ *res = (((*op1)) - ((*op2))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_multiply_real64_t (const real64_t *op1, const real64_t *op2, real64_t *res){ *res = (((*op1)) * ((*op2))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_divide_real64_t (const real64_t *op1, const real64_t *op2, real64_t *res){ *res = (((*op1)) / ((*op2))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_modulo_real64_t (const real64_t *op1, const real64_t *op2, real64_t *res){ *res = (fmod(((*op1)), ((*op2)))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_atan2_real64_t (const real64_t *op1, const real64_t *op2, real64_t *res){ *res = (atan2(((*op1)), ((*op2)))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_equal_real64_t (const real64_t *op1, const real64_t *op2, ajla_flat_option_t *res){ real64_t o1 = (*op1); real64_t o2 = (*op2); if (((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))) return 0; *res = o1 == o2; return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_not_equal_real64_t (const real64_t *op1, const real64_t *op2, ajla_flat_option_t *res){ real64_t o1 = (*op1); real64_t o2 = (*op2); if (((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))) return 0; *res = __builtin_islessgreater(o1, o2); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_less_real64_t (const real64_t *op1, const real64_t *op2, ajla_flat_option_t *res){ real64_t o1 = (*op1); real64_t o2 = (*op2); if (((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))) return 0; *res = __builtin_isless(o1, o2); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_less_equal_real64_t (const real64_t *op1, const real64_t *op2, ajla_flat_option_t *res){ real64_t o1 = (*op1); real64_t o2 = (*op2); if (((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))) return 0; *res = __builtin_islessequal(o1, o2); return 1; } static inline __attribute__((__always_inline__)) void REAL_unary_neg_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!0) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (-((*op1))); } static inline __attribute__((__always_inline__)) void REAL_unary_sqrt_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (sqrt(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_cbrt_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (cbrt(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_sin_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (sin(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_cos_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (cos(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_tan_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (tan(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_asin_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (asin(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_acos_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (acos(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_atan_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (atan(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_sinh_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (sinh(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_cosh_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (cosh(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_tanh_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (tanh(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_asinh_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (asinh(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_acosh_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (acosh(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_atanh_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (atanh(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_exp2_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (exp2(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_exp_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (exp(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_exp10_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (exp10(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_log2_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (log2(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_log_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (log(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_log10_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (log10(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_round_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (rint(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_ceil_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (ceil(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_floor_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (floor(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_trunc_real64_t (const real64_t *op1, real64_t *res) { if (!2 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (trunc(((*op1)))); } static inline __attribute__((__always_inline__)) _Bool REAL_binary_power_real64_t (const real64_t *op1, const real64_t *op2, real64_t *res){ real64_t o1 = (*op1); real64_t o2 = (*op2); real64_t r; if ((__builtin_expect((int)(((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))), 0))) return 0; r = pow(o1, o2); *res = (r); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_ldexp_real64_t (const real64_t *op1, const real64_t *op2, real64_t *res){ real64_t m; real64_t o1 = (*op1); real64_t o2 = (*op2); if ((__builtin_expect((int)(((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))), 0))) return 0; if ((__builtin_expect((int)(o2 >= (real64_t)((int)(-((int)1 << (8 * sizeof(int) - 2)) * 2))), 1)) && (__builtin_expect((int)(o2 <= (real64_t)(~((int)(-((int)1 << (8 * sizeof(int) - 2)) * 2)))), 1)) && (__builtin_expect((int)(o2 == (int)o2), 1))) { *res = (ldexp(o1, (int)o2)); } else { m = exp2(o2); m *= o1; *res = (m); } return 1; } static inline __attribute__((__always_inline__)) void REAL_unary_fract_real64_t (const real64_t *op1, real64_t *res) { real64_t m = (*op1); union { real64_t i; float f; } u; if (0) { if ((__builtin_expect((int)(!__builtin_isnan (m)), 1)) && (__builtin_expect((int)(!(((__builtin_huge_val ()) == (__builtin_huge_val ()) / 2) && fabs(m) < (__builtin_huge_val ()))), 0))) { *res = (m >= 0 ? 0. : -0.); return; } } *res = (modf(m, (void *)&u)); } static inline __attribute__((__always_inline__)) void REAL_unary_mantissa_real64_t (const real64_t *op1, real64_t *res) { int i; *res = (frexp((*op1), &i)); } static inline __attribute__((__always_inline__)) void REAL_unary_exponent_real64_t (const real64_t *op1, real64_t *res) { int i; real64_t m = frexp((*op1), &i); if ((__builtin_expect((int)(__builtin_isnan (m)), 0))) { *res = (m); return; } if ((__builtin_expect((int)(!(((__builtin_huge_val ()) == (__builtin_huge_val ()) / 2) && fabs(m) < (__builtin_huge_val ()))), 0))) { *res = ((real64_t)0.); return; } *res = ((real64_t)i); } static inline __attribute__((__always_inline__)) real64_t REAL_unary_next_prev_number_real64_t (real64_t op1, int dir) { int ex, bit; volatile real64_t m, mm, n1; volatile real64_t res, o; if ((__builtin_expect((int)(__builtin_isnan (op1)), 0))) return op1; n1 = (op1); if ((__builtin_expect((int)(!(((__builtin_huge_val ()) == (__builtin_huge_val ()) / 2) && fabs(op1) < (__builtin_huge_val ()))), 0))) { if ((n1 >= 0) == (dir >= 0)) return op1; m = ldexp(1, 53) - 1; while (1) { mm = m * 2; res = (mm); if ((__builtin_expect((int)(!(((__builtin_huge_val ()) == (__builtin_huge_val ()) / 2) && fabs(res) < (__builtin_huge_val ()))), 0))) break; m = mm; } return (m * -dir); } if ((__builtin_expect((int)(!n1), 0))) { res = (1); o = (1); while (1) { o = ((o) * 0.5); m = (o); if (m == 0) break; res = o; } return ((res) * dir); } m = frexp(n1, &ex); bit = 53; again: mm = m + ldexp(dir, -bit); o = (ldexp(mm, ex)); res = o; if ((res) == n1) { bit--; goto again; } return res; } static inline __attribute__((__always_inline__)) void REAL_unary_next_number_real64_t (const real64_t *op1, real64_t *res) { if (do_nextafter_real64_t(*op1, 1, res)) return; *res = REAL_unary_next_prev_number_real64_t(*op1, 1); } static inline __attribute__((__always_inline__)) void REAL_unary_prev_number_real64_t (const real64_t *op1, real64_t *res) { if (do_nextafter_real64_t(*op1, -1, res)) return; *res = REAL_unary_next_prev_number_real64_t(*op1, -1); } static inline __attribute__((__always_inline__)) _Bool REAL_unary_to_int_real64_t(const real64_t *val, int64_t *r){ real64_t val1; val1 = (*val); if ((__builtin_expect((int)(val1 > (real64_t)((int64_t)(-((int64_t)1 << (8 * sizeof(int64_t) - 2)) * 2))), 1)) && (__builtin_expect((int)(val1 < (real64_t)(~((int64_t)(-((int64_t)1 << (8 * sizeof(int64_t) - 2)) * 2)))), 1))) { *r = val1; return 1; } return 0; } static inline __attribute__((__always_inline__)) void REAL_unary_from_int_real64_t(const int64_t *val, real64_t *r){ *r = (*val); } static inline __attribute__((__always_inline__)) void REAL_unary_is_exception_real64_t (const real64_t *op1, ajla_flat_option_t *res){ *res = __builtin_isnan (*op1); }static inline __attribute__((__always_inline__)) size_t fixed_ldc_real64_t (real64_t *res, const code_t *ip, _Bool __attribute__((__unused__)) shrt){ memcpy(res, ip, sizeof(real64_t)); return (((sizeof(real64_t)) + (sizeof(code_t)) - 1) & ~((sizeof(code_t)) - 1 + 0 * (sizeof(real64_t)))) / sizeof(code_t);} static inline __attribute__((__always_inline__)) _Bool REAL_binary_add_real80_t (const real80_t *op1, const real80_t *op2, real80_t *res){ *res = (((*op1)) + ((*op2))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_subtract_real80_t (const real80_t *op1, const real80_t *op2, real80_t *res){ *res = (((*op1)) - ((*op2))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_multiply_real80_t (const real80_t *op1, const real80_t *op2, real80_t *res){ *res = (((*op1)) * ((*op2))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_divide_real80_t (const real80_t *op1, const real80_t *op2, real80_t *res){ *res = (((*op1)) / ((*op2))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_modulo_real80_t (const real80_t *op1, const real80_t *op2, real80_t *res){ *res = (fmodl(((*op1)), ((*op2)))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_atan2_real80_t (const real80_t *op1, const real80_t *op2, real80_t *res){ *res = (atan2l(((*op1)), ((*op2)))); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_equal_real80_t (const real80_t *op1, const real80_t *op2, ajla_flat_option_t *res){ real80_t o1 = (*op1); real80_t o2 = (*op2); if (((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))) return 0; *res = o1 == o2; return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_not_equal_real80_t (const real80_t *op1, const real80_t *op2, ajla_flat_option_t *res){ real80_t o1 = (*op1); real80_t o2 = (*op2); if (((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))) return 0; *res = __builtin_islessgreater(o1, o2); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_less_real80_t (const real80_t *op1, const real80_t *op2, ajla_flat_option_t *res){ real80_t o1 = (*op1); real80_t o2 = (*op2); if (((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))) return 0; *res = __builtin_isless(o1, o2); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_less_equal_real80_t (const real80_t *op1, const real80_t *op2, ajla_flat_option_t *res){ real80_t o1 = (*op1); real80_t o2 = (*op2); if (((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))) return 0; *res = __builtin_islessequal(o1, o2); return 1; } static inline __attribute__((__always_inline__)) void REAL_unary_neg_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!0) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (-((*op1))); } static inline __attribute__((__always_inline__)) void REAL_unary_sqrt_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (sqrtl(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_cbrt_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (cbrtl(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_sin_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (sinl(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_cos_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (cosl(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_tan_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (tanl(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_asin_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (asinl(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_acos_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (acosl(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_atan_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (atanl(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_sinh_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (sinhl(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_cosh_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (coshl(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_tanh_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (tanhl(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_asinh_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (asinhl(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_acosh_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (acoshl(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_atanh_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (atanhl(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_exp2_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (exp2l(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_exp_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (expl(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_exp10_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (exp10l(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_log2_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (log2l(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_log_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (logl(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_log10_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (log10l(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_round_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (rintl(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_ceil_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (ceill(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_floor_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (floorl(((*op1)))); } static inline __attribute__((__always_inline__)) void REAL_unary_trunc_real80_t (const real80_t *op1, real80_t *res) { if (!3 && 1) { if (!1) { *(uint16_t *)res = *(uint16_t *)op1 ^ 0x8000U; return; } } *res = (truncl(((*op1)))); } static inline __attribute__((__always_inline__)) _Bool REAL_binary_power_real80_t (const real80_t *op1, const real80_t *op2, real80_t *res){ real80_t o1 = (*op1); real80_t o2 = (*op2); real80_t r; if ((__builtin_expect((int)(((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))), 0))) return 0; r = powl(o1, o2); *res = (r); return 1; } static inline __attribute__((__always_inline__)) _Bool REAL_binary_ldexp_real80_t (const real80_t *op1, const real80_t *op2, real80_t *res){ real80_t m; real80_t o1 = (*op1); real80_t o2 = (*op2); if ((__builtin_expect((int)(((__builtin_expect((int)(__builtin_isunordered(o1, o2)), 0)))), 0))) return 0; if ((__builtin_expect((int)(o2 >= (real80_t)((int)(-((int)1 << (8 * sizeof(int) - 2)) * 2))), 1)) && (__builtin_expect((int)(o2 <= (real80_t)(~((int)(-((int)1 << (8 * sizeof(int) - 2)) * 2)))), 1)) && (__builtin_expect((int)(o2 == (int)o2), 1))) { *res = (ldexpl(o1, (int)o2)); } else { m = exp2l(o2); m *= o1; *res = (m); } return 1; } static inline __attribute__((__always_inline__)) void REAL_unary_fract_real80_t (const real80_t *op1, real80_t *res) { real80_t m = (*op1); union { real80_t i; float f; } u; if (0) { if ((__builtin_expect((int)(!isnanl(m)), 1)) && (__builtin_expect((int)(!(((__builtin_huge_val ()) == (__builtin_huge_val ()) / 2) && fabsl(m) < (__builtin_huge_val ()))), 0))) { *res = (m >= 0 ? 0. : -0.); return; } } *res = (modfl(m, (void *)&u)); } static inline __attribute__((__always_inline__)) void REAL_unary_mantissa_real80_t (const real80_t *op1, real80_t *res) { int i; *res = (frexpl((*op1), &i)); } static inline __attribute__((__always_inline__)) void REAL_unary_exponent_real80_t (const real80_t *op1, real80_t *res) { int i; real80_t m = frexpl((*op1), &i); if ((__builtin_expect((int)(isnanl(m)), 0))) { *res = (m); return; } if ((__builtin_expect((int)(!(((__builtin_huge_val ()) == (__builtin_huge_val ()) / 2) && fabsl(m) < (__builtin_huge_val ()))), 0))) { *res = ((real80_t)0.); return; } *res = ((real80_t)i); } static inline __attribute__((__always_inline__)) real80_t REAL_unary_next_prev_number_real80_t (real80_t op1, int dir) { int ex, bit; volatile real80_t m, mm, n1; volatile real80_t res, o; if ((__builtin_expect((int)(isnanl(op1)), 0))) return op1; n1 = (op1); if ((__builtin_expect((int)(!(((__builtin_huge_val ()) == (__builtin_huge_val ()) / 2) && fabsl(op1) < (__builtin_huge_val ()))), 0))) { if ((n1 >= 0) == (dir >= 0)) return op1; m = ldexpl(1, 64) - 1; while (1) { mm = m * 2; res = (mm); if ((__builtin_expect((int)(!(((__builtin_huge_val ()) == (__builtin_huge_val ()) / 2) && fabsl(res) < (__builtin_huge_val ()))), 0))) break; m = mm; } return (m * -dir); } if ((__builtin_expect((int)(!n1), 0))) { res = (1); o = (1); while (1) { o = ((o) * 0.5); m = (o); if (m == 0) break; res = o; } return ((res) * dir); } m = frexpl(n1, &ex); bit = 64; again: mm = m + ldexpl(dir, -bit); o = (ldexpl(mm, ex)); res = o; if ((res) == n1) { bit--; goto again; } return res; } static inline __attribute__((__always_inline__)) void REAL_unary_next_number_real80_t (const real80_t *op1, real80_t *res) { if (do_nextafter_real80_t(*op1, 1, res)) return; *res = REAL_unary_next_prev_number_real80_t(*op1, 1); } static inline __attribute__((__always_inline__)) void REAL_unary_prev_number_real80_t (const real80_t *op1, real80_t *res) { if (do_nextafter_real80_t(*op1, -1, res)) return; *res = REAL_unary_next_prev_number_real80_t(*op1, -1); } static inline __attribute__((__always_inline__)) _Bool REAL_unary_to_int_real80_t(const real80_t *val, int64_t *r){ real80_t val1; val1 = (*val); if ((__builtin_expect((int)(val1 > (real80_t)((int64_t)(-((int64_t)1 << (8 * sizeof(int64_t) - 2)) * 2))), 1)) && (__builtin_expect((int)(val1 < (real80_t)(~((int64_t)(-((int64_t)1 << (8 * sizeof(int64_t) - 2)) * 2)))), 1))) { *r = val1; return 1; } return 0; } static inline __attribute__((__always_inline__)) void REAL_unary_from_int_real80_t(const int64_t *val, real80_t *r){ *r = (*val); } static inline __attribute__((__always_inline__)) void REAL_unary_is_exception_real80_t (const real80_t *op1, ajla_flat_option_t *res){ *res = isnanl(*op1); }static inline __attribute__((__always_inline__)) size_t fixed_ldc_real80_t (real80_t *res, const code_t *ip, _Bool __attribute__((__unused__)) shrt){ memcpy(res, ip, sizeof(real80_t)); return (((sizeof(real80_t)) + (sizeof(code_t)) - 1) & ~((sizeof(code_t)) - 1 + 0 * (sizeof(real80_t)))) / sizeof(code_t);}



static inline frame_s *frame_build(frame_s *fp, struct data *function, ajla_error_t *mayfail)
{
 frame_t new_frame_slots = ((((void)(zero_()))), &(function)->u_.function)->frame_slots;
 if ((__builtin_expect((int)(new_frame_slots <= (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->available_slots), 1))) {
  frame_s *new_fp = ((frame_s *)(void *)(((char *)(void *)(fp)) - new_frame_slots * ((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))));
  (((struct frame_struct *)(void *)(((const char *)(void *)(new_fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->available_slots = (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->available_slots - new_frame_slots;
  (((struct frame_struct *)(void *)(((const char *)(void *)(new_fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function = function;
  return new_fp;
 } else {
  return u_stack_expand(fp, function, mayfail);
 }
}
# 582 "ipret.c"
# 1 "./ipret.inc" 1
# 48 "./ipret.inc"
# 1 "./ipret-1.inc" 1
# 36 "./ipret-1.inc"
static const code_t __attribute__((__noinline__)) *free_parameters_0(frame_s *fp, const code_t *ip, frame_t n_entries)
{
 while (n_entries--) {
  if ((!((1) & 1) ? (((const unsigned char *)((ip) + (1) / 2))[0]) : (((const unsigned char *)((ip) + (1) / 2))[1])) & 0x0002)
   frame_free_and_clear(fp, (!((0) & 1) ? (((const unsigned char *)((ip) + (0) / 2))[0]) : (((const unsigned char *)((ip) + (0) / 2))[1])));
  (ip += ((((2) + 1) / 2)));
 }
 return ip;
}
# 688 "./ipret-1.inc"
# 1 "./for-fix.inc" 1
# 24 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 74 "./ipret-a1.inc" 2
# 25 "./for-fix.inc" 2
# 36 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 74 "./ipret-a1.inc" 2
# 37 "./for-fix.inc" 2
# 48 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 74 "./ipret-a1.inc" 2
# 49 "./for-fix.inc" 2
# 60 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 74 "./ipret-a1.inc" 2
# 61 "./for-fix.inc" 2
# 72 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 74 "./ipret-a1.inc" 2
# 73 "./for-fix.inc" 2
# 689 "./ipret-1.inc" 2


# 1 "./for-int.inc" 1
# 24 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a2.inc" 2
# 25 "./for-int.inc" 2
# 36 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a2.inc" 2
# 37 "./for-int.inc" 2
# 48 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a2.inc" 2
# 49 "./for-int.inc" 2
# 60 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a2.inc" 2
# 61 "./for-int.inc" 2
# 72 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a2.inc" 2
# 73 "./for-int.inc" 2
# 692 "./ipret-1.inc" 2


# 1 "./for-real.inc" 1
# 23 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 118 "./ipret-a3.inc" 2
# 149 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 150 "./ipret-a3.inc" 2
# 163 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 164 "./ipret-a3.inc" 2
# 24 "./for-real.inc" 2
# 33 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 118 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 125 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 131 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 137 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 143 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 150 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 157 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 164 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 171 "./ipret-a3.inc" 2







# 1 "./ipret-b1.inc" 1
# 179 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 185 "./ipret-a3.inc" 2
# 34 "./for-real.inc" 2
# 43 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 118 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 125 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 131 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 137 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 143 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 150 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 157 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 164 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 171 "./ipret-a3.inc" 2







# 1 "./ipret-b1.inc" 1
# 179 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 185 "./ipret-a3.inc" 2
# 44 "./for-real.inc" 2
# 53 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 54 "./for-real.inc" 2
# 695 "./ipret-1.inc" 2
# 49 "./ipret.inc" 2






# 1 "./ipret-1.inc" 1
# 36 "./ipret-1.inc"
static const code_t __attribute__((__noinline__)) *free_parameters_1(frame_s *fp, const code_t *ip, frame_t n_entries)
{
 while (n_entries--) {
  if (((uintptr_t)(ip)[1]) & 0x0002)
   frame_free_and_clear(fp, ((uintptr_t)(ip)[0]));
  (ip += ((2)));
 }
 return ip;
}
# 688 "./ipret-1.inc"
# 1 "./for-fix.inc" 1
# 24 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 74 "./ipret-a1.inc" 2
# 25 "./for-fix.inc" 2
# 36 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 74 "./ipret-a1.inc" 2
# 37 "./for-fix.inc" 2
# 48 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 74 "./ipret-a1.inc" 2
# 49 "./for-fix.inc" 2
# 60 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 74 "./ipret-a1.inc" 2
# 61 "./for-fix.inc" 2
# 72 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 74 "./ipret-a1.inc" 2
# 73 "./for-fix.inc" 2
# 689 "./ipret-1.inc" 2


# 1 "./for-int.inc" 1
# 24 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a2.inc" 2
# 25 "./for-int.inc" 2
# 36 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a2.inc" 2
# 37 "./for-int.inc" 2
# 48 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a2.inc" 2
# 49 "./for-int.inc" 2
# 60 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a2.inc" 2
# 61 "./for-int.inc" 2
# 72 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a2.inc" 2
# 73 "./for-int.inc" 2
# 692 "./ipret-1.inc" 2


# 1 "./for-real.inc" 1
# 23 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 118 "./ipret-a3.inc" 2
# 149 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 150 "./ipret-a3.inc" 2
# 163 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 164 "./ipret-a3.inc" 2
# 24 "./for-real.inc" 2
# 33 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 118 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 125 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 131 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 137 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 143 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 150 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 157 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 164 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 171 "./ipret-a3.inc" 2







# 1 "./ipret-b1.inc" 1
# 179 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 185 "./ipret-a3.inc" 2
# 34 "./for-real.inc" 2
# 43 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 118 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 125 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 131 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 137 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 143 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 150 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 157 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 164 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 171 "./ipret-a3.inc" 2







# 1 "./ipret-b1.inc" 1
# 179 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 185 "./ipret-a3.inc" 2
# 44 "./for-real.inc" 2
# 53 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 54 "./for-real.inc" 2
# 695 "./ipret-1.inc" 2
# 56 "./ipret.inc" 2





# 1 "./ipret-1.inc" 1
# 36 "./ipret-1.inc"
static const code_t __attribute__((__noinline__)) *free_parameters_2(frame_s *fp, const code_t *ip, frame_t n_entries)
{
 while (n_entries--) {
  if (get_unaligned_32(&(ip)[(1) * 2]) & 0x0002)
   frame_free_and_clear(fp, get_unaligned_32(&(ip)[(0) * 2]));
  (ip += (((2) * 2)));
 }
 return ip;
}
# 688 "./ipret-1.inc"
# 1 "./for-fix.inc" 1
# 24 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 74 "./ipret-a1.inc" 2
# 25 "./for-fix.inc" 2
# 36 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 74 "./ipret-a1.inc" 2
# 37 "./for-fix.inc" 2
# 48 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 74 "./ipret-a1.inc" 2
# 49 "./for-fix.inc" 2
# 60 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 74 "./ipret-a1.inc" 2
# 61 "./for-fix.inc" 2
# 72 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 74 "./ipret-a1.inc" 2
# 73 "./for-fix.inc" 2
# 689 "./ipret-1.inc" 2


# 1 "./for-int.inc" 1
# 24 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a2.inc" 2
# 25 "./for-int.inc" 2
# 36 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a2.inc" 2
# 37 "./for-int.inc" 2
# 48 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a2.inc" 2
# 49 "./for-int.inc" 2
# 60 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a2.inc" 2
# 61 "./for-int.inc" 2
# 72 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a2.inc" 2
# 73 "./for-int.inc" 2
# 692 "./ipret-1.inc" 2


# 1 "./for-real.inc" 1
# 23 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 118 "./ipret-a3.inc" 2
# 149 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 150 "./ipret-a3.inc" 2
# 163 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 164 "./ipret-a3.inc" 2
# 24 "./for-real.inc" 2
# 33 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 118 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 125 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 131 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 137 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 143 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 150 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 157 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 164 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 171 "./ipret-a3.inc" 2







# 1 "./ipret-b1.inc" 1
# 179 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 185 "./ipret-a3.inc" 2
# 34 "./for-real.inc" 2
# 43 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 118 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 125 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 131 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 137 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 143 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 150 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 157 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 164 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 171 "./ipret-a3.inc" 2







# 1 "./ipret-b1.inc" 1
# 179 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 185 "./ipret-a3.inc" 2
# 44 "./for-real.inc" 2
# 53 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 54 "./for-real.inc" 2
# 695 "./ipret-1.inc" 2
# 62 "./ipret.inc" 2
# 583 "ipret.c" 2

void u_run(frame_s *fp_, ip_t ip_)
{
 ajla_error_t ajla_error;
 tick_stamp_t ts;




 register frame_s *fp
# 610 "ipret.c"
  ;
 register const code_t *ip




  ;
 code_t code;


 const void *next_label;





 static const void *dispatch[OPCODE_MODE_MULT * 3 - (OPCODE_MODE_MULT - OPCODE_N)] = {



# 1 "./ipret.inc" 1
# 48 "./ipret.inc"
# 1 "./ipret-1.inc" 1
# 317 "./ipret-1.inc"
 [((0 + 0 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_add_int8_t_0, [((0 + 1 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_subtract_int8_t_0, [((0 + 2 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_multiply_int8_t_0, [((0 + 3 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_divide_int8_t_0, [((0 + 5 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_udivide_int8_t_0, [((0 + 7 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_modulo_int8_t_0, [((0 + 9 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_umodulo_int8_t_0, [((0 + 11 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_power_int8_t_0, [((0 + 12 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_and_int8_t_0, [((0 + 13 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_or_int8_t_0, [((0 + 14 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_xor_int8_t_0, [((0 + 15 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shl_int8_t_0, [((0 + 16 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shr_int8_t_0, [((0 + 17 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ushr_int8_t_0, [((0 + 18 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_rol_int8_t_0, [((0 + 19 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ror_int8_t_0, [((0 + 20 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bts_int8_t_0, [((0 + 21 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btr_int8_t_0, [((0 + 22 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btc_int8_t_0, [((0 + 23 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_equal_int8_t_0, [((0 + 24 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_not_equal_int8_t_0, [((0 + 25 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_int8_t_0, [((0 + 26 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_equal_int8_t_0, [((0 + 27 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_int8_t_0, [((0 + 28 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_equal_int8_t_0, [((0 + 29 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bt_int8_t_0, [((0 + 30 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_not_int8_t_0, [((0 + 31 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_neg_int8_t_0, [((0 + 32 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_inc_int8_t_0, [((0 + 33 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_dec_int8_t_0, [((0 + 34 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bswap_int8_t_0, [((0 + 36 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_brev_int8_t_0, [((0 + 38 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsf_int8_t_0, [((0 + 40 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_int8_t_0, [((0 + 42 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_int8_t_0, [((0 + 44 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_to_int_int8_t_0, [((0 + 45 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_uto_int_int8_t_0, [((0 + 46 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_from_int_int8_t_0, [((0 + 47 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_ufrom_int_int8_t_0, [((0 + 48 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_move_int8_t_0, [((0 + 49 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_copy_int8_t_0, [((0 + 50 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_int8_t_0, [((0 + 0 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_add_int16_t_0, [((0 + 1 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_subtract_int16_t_0, [((0 + 2 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_multiply_int16_t_0, [((0 + 3 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_divide_int16_t_0, [((0 + 5 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_udivide_int16_t_0, [((0 + 7 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_modulo_int16_t_0, [((0 + 9 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_umodulo_int16_t_0, [((0 + 11 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_power_int16_t_0, [((0 + 12 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_and_int16_t_0, [((0 + 13 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_or_int16_t_0, [((0 + 14 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_xor_int16_t_0, [((0 + 15 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shl_int16_t_0, [((0 + 16 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shr_int16_t_0, [((0 + 17 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ushr_int16_t_0, [((0 + 18 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_rol_int16_t_0, [((0 + 19 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ror_int16_t_0, [((0 + 20 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bts_int16_t_0, [((0 + 21 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btr_int16_t_0, [((0 + 22 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btc_int16_t_0, [((0 + 23 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_equal_int16_t_0, [((0 + 24 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_not_equal_int16_t_0, [((0 + 25 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_int16_t_0, [((0 + 26 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_equal_int16_t_0, [((0 + 27 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_int16_t_0, [((0 + 28 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_equal_int16_t_0, [((0 + 29 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bt_int16_t_0, [((0 + 30 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_not_int16_t_0, [((0 + 31 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_neg_int16_t_0, [((0 + 32 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_inc_int16_t_0, [((0 + 33 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_dec_int16_t_0, [((0 + 34 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bswap_int16_t_0, [((0 + 36 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_brev_int16_t_0, [((0 + 38 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsf_int16_t_0, [((0 + 40 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_int16_t_0, [((0 + 42 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_int16_t_0, [((0 + 44 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_to_int_int16_t_0, [((0 + 45 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_uto_int_int16_t_0, [((0 + 46 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_from_int_int16_t_0, [((0 + 47 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_ufrom_int_int16_t_0, [((0 + 48 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_move_int16_t_0, [((0 + 49 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_copy_int16_t_0, [((0 + 50 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_int16_t_0, [((0 + 0 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_add_int32_t_0, [((0 + 1 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_subtract_int32_t_0, [((0 + 2 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_multiply_int32_t_0, [((0 + 3 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_divide_int32_t_0, [((0 + 5 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_udivide_int32_t_0, [((0 + 7 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_modulo_int32_t_0, [((0 + 9 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_umodulo_int32_t_0, [((0 + 11 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_power_int32_t_0, [((0 + 12 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_and_int32_t_0, [((0 + 13 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_or_int32_t_0, [((0 + 14 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_xor_int32_t_0, [((0 + 15 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shl_int32_t_0, [((0 + 16 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shr_int32_t_0, [((0 + 17 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ushr_int32_t_0, [((0 + 18 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_rol_int32_t_0, [((0 + 19 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ror_int32_t_0, [((0 + 20 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bts_int32_t_0, [((0 + 21 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btr_int32_t_0, [((0 + 22 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btc_int32_t_0, [((0 + 23 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_equal_int32_t_0, [((0 + 24 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_not_equal_int32_t_0, [((0 + 25 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_int32_t_0, [((0 + 26 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_equal_int32_t_0, [((0 + 27 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_int32_t_0, [((0 + 28 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_equal_int32_t_0, [((0 + 29 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bt_int32_t_0, [((0 + 30 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_not_int32_t_0, [((0 + 31 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_neg_int32_t_0, [((0 + 32 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_inc_int32_t_0, [((0 + 33 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_dec_int32_t_0, [((0 + 34 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bswap_int32_t_0, [((0 + 36 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_brev_int32_t_0, [((0 + 38 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsf_int32_t_0, [((0 + 40 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_int32_t_0, [((0 + 42 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_int32_t_0, [((0 + 44 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_to_int_int32_t_0, [((0 + 45 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_uto_int_int32_t_0, [((0 + 46 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_from_int_int32_t_0, [((0 + 47 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_ufrom_int_int32_t_0, [((0 + 48 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_move_int32_t_0, [((0 + 49 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_copy_int32_t_0, [((0 + 50 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_int32_t_0, [((0 + 0 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_add_int64_t_0, [((0 + 1 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_subtract_int64_t_0, [((0 + 2 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_multiply_int64_t_0, [((0 + 3 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_divide_int64_t_0, [((0 + 5 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_udivide_int64_t_0, [((0 + 7 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_modulo_int64_t_0, [((0 + 9 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_umodulo_int64_t_0, [((0 + 11 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_power_int64_t_0, [((0 + 12 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_and_int64_t_0, [((0 + 13 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_or_int64_t_0, [((0 + 14 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_xor_int64_t_0, [((0 + 15 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shl_int64_t_0, [((0 + 16 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shr_int64_t_0, [((0 + 17 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ushr_int64_t_0, [((0 + 18 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_rol_int64_t_0, [((0 + 19 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ror_int64_t_0, [((0 + 20 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bts_int64_t_0, [((0 + 21 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btr_int64_t_0, [((0 + 22 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btc_int64_t_0, [((0 + 23 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_equal_int64_t_0, [((0 + 24 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_not_equal_int64_t_0, [((0 + 25 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_int64_t_0, [((0 + 26 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_equal_int64_t_0, [((0 + 27 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_int64_t_0, [((0 + 28 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_equal_int64_t_0, [((0 + 29 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bt_int64_t_0, [((0 + 30 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_not_int64_t_0, [((0 + 31 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_neg_int64_t_0, [((0 + 32 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_inc_int64_t_0, [((0 + 33 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_dec_int64_t_0, [((0 + 34 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bswap_int64_t_0, [((0 + 36 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_brev_int64_t_0, [((0 + 38 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsf_int64_t_0, [((0 + 40 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_int64_t_0, [((0 + 42 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_int64_t_0, [((0 + 44 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_to_int_int64_t_0, [((0 + 45 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_uto_int_int64_t_0, [((0 + 46 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_from_int_int64_t_0, [((0 + 47 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_ufrom_int_int64_t_0, [((0 + 48 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_move_int64_t_0, [((0 + 49 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_copy_int64_t_0, [((0 + 50 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_int64_t_0, [((0 + 0 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_add_int128_t_0, [((0 + 1 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_subtract_int128_t_0, [((0 + 2 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_multiply_int128_t_0, [((0 + 3 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_divide_int128_t_0, [((0 + 5 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_udivide_int128_t_0, [((0 + 7 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_modulo_int128_t_0, [((0 + 9 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_umodulo_int128_t_0, [((0 + 11 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_power_int128_t_0, [((0 + 12 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_and_int128_t_0, [((0 + 13 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_or_int128_t_0, [((0 + 14 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_xor_int128_t_0, [((0 + 15 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shl_int128_t_0, [((0 + 16 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shr_int128_t_0, [((0 + 17 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ushr_int128_t_0, [((0 + 18 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_rol_int128_t_0, [((0 + 19 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ror_int128_t_0, [((0 + 20 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bts_int128_t_0, [((0 + 21 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btr_int128_t_0, [((0 + 22 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btc_int128_t_0, [((0 + 23 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_equal_int128_t_0, [((0 + 24 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_not_equal_int128_t_0, [((0 + 25 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_int128_t_0, [((0 + 26 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_equal_int128_t_0, [((0 + 27 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_int128_t_0, [((0 + 28 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_equal_int128_t_0, [((0 + 29 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bt_int128_t_0, [((0 + 30 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_not_int128_t_0, [((0 + 31 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_neg_int128_t_0, [((0 + 32 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_inc_int128_t_0, [((0 + 33 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_dec_int128_t_0, [((0 + 34 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bswap_int128_t_0, [((0 + 36 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_brev_int128_t_0, [((0 + 38 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsf_int128_t_0, [((0 + 40 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_int128_t_0, [((0 + 42 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_int128_t_0, [((0 + 44 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_to_int_int128_t_0, [((0 + 45 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_uto_int_int128_t_0, [((0 + 46 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_from_int_int128_t_0, [((0 + 47 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_ufrom_int_int128_t_0, [((0 + 48 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_move_int128_t_0, [((0 + 49 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_copy_int128_t_0, [((0 + 50 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_int128_t_0,


[((0 + 51 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_fixed_ldc16_int32_t_0,

[((0 + 51 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_fixed_ldc16_int64_t_0,

[((0 + 51 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_fixed_ldc16_int128_t_0,
# 420 "./ipret-1.inc"
 [((((0 + 52 * 5) + 35 * 5) + 0 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 3 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 6 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 9 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 12 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_modulo_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 13 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_power_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 14 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_ldexp_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 15 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_atan2_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 16 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 19 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 22 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 25 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 28 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 31 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 35 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cbrt_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 36 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sin_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 37 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cos_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 38 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tan_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 39 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asin_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 40 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acos_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 41 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atan_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 42 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sinh_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 43 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cosh_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 44 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tanh_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 45 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asinh_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 46 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acosh_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 47 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atanh_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 48 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp2_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 49 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 50 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp10_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 51 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log2_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 52 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 53 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log10_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 54 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_round_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 56 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_ceil_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 55 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_floor_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 57 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_trunc_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 58 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_fract_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 59 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_mantissa_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 60 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exponent_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 61 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_next_number_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 62 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_prev_number_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 63 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 66 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 69 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 72 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_move_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 73 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_copy_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 74 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_real16_t_0, [((((0 + 52 * 5) + 35 * 5) + 0 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 3 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 6 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 9 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 12 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_modulo_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 13 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_power_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 14 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_ldexp_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 15 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_atan2_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 16 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 19 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 22 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 25 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 28 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 31 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 35 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cbrt_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 36 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sin_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 37 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cos_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 38 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tan_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 39 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asin_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 40 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acos_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 41 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atan_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 42 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sinh_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 43 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cosh_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 44 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tanh_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 45 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asinh_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 46 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acosh_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 47 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atanh_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 48 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp2_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 49 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 50 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp10_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 51 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log2_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 52 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 53 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log10_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 54 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_round_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 56 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_ceil_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 55 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_floor_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 57 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_trunc_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 58 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_fract_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 59 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_mantissa_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 60 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exponent_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 61 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_next_number_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 62 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_prev_number_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 63 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 66 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 69 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 72 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_move_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 73 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_copy_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 74 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_real32_t_0, [((((0 + 52 * 5) + 35 * 5) + 0 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 3 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 6 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 9 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 12 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_modulo_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 13 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_power_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 14 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_ldexp_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 15 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_atan2_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 16 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 19 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 22 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 25 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 28 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 31 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 35 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cbrt_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 36 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sin_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 37 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cos_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 38 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tan_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 39 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asin_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 40 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acos_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 41 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atan_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 42 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sinh_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 43 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cosh_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 44 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tanh_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 45 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asinh_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 46 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acosh_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 47 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atanh_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 48 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp2_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 49 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 50 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp10_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 51 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log2_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 52 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 53 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log10_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 54 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_round_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 56 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_ceil_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 55 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_floor_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 57 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_trunc_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 58 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_fract_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 59 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_mantissa_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 60 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exponent_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 61 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_next_number_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 62 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_prev_number_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 63 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 66 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 69 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 72 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_move_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 73 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_copy_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 74 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_real64_t_0, [((((0 + 52 * 5) + 35 * 5) + 0 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 3 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 6 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 9 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 12 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_modulo_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 13 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_power_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 14 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_ldexp_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 15 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_atan2_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 16 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 19 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 22 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 25 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 28 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 31 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 35 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cbrt_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 36 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sin_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 37 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cos_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 38 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tan_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 39 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asin_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 40 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acos_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 41 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atan_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 42 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sinh_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 43 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cosh_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 44 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tanh_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 45 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asinh_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 46 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acosh_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 47 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atanh_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 48 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp2_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 49 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 50 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp10_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 51 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log2_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 52 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 53 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log10_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 54 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_round_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 56 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_ceil_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 55 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_floor_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 57 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_trunc_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 58 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_fract_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 59 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_mantissa_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 60 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exponent_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 61 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_next_number_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 62 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_prev_number_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 63 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 66 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 69 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 72 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_move_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 73 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_copy_real80_t_0, [((((0 + 52 * 5) + 35 * 5) + 74 * 1 + 3 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_real80_t_0,
# 655 "./ipret-1.inc"
[(((0 + 52 * 5) + 0 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_add_int8_t_0, [(((0 + 52 * 5) + 1 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_subtract_int8_t_0, [(((0 + 52 * 5) + 2 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_multiply_int8_t_0, [(((0 + 52 * 5) + 3 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_divide_int8_t_0, [(((0 + 52 * 5) + 5 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_modulo_int8_t_0, [(((0 + 52 * 5) + 7 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_power_int8_t_0, [(((0 + 52 * 5) + 8 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_and_int8_t_0, [(((0 + 52 * 5) + 9 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_or_int8_t_0, [(((0 + 52 * 5) + 10 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_xor_int8_t_0, [(((0 + 52 * 5) + 11 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_shl_int8_t_0, [(((0 + 52 * 5) + 12 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_shr_int8_t_0, [(((0 + 52 * 5) + 13 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_bts_int8_t_0, [(((0 + 52 * 5) + 14 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_btr_int8_t_0, [(((0 + 52 * 5) + 15 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_btc_int8_t_0, [(((0 + 52 * 5) + 16 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_equal_int8_t_0, [(((0 + 52 * 5) + 17 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_not_equal_int8_t_0, [(((0 + 52 * 5) + 18 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_less_int8_t_0, [(((0 + 52 * 5) + 19 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_less_equal_int8_t_0, [(((0 + 52 * 5) + 20 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_bt_int8_t_0, [(((0 + 52 * 5) + 21 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_not_int8_t_0, [(((0 + 52 * 5) + 22 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_neg_int8_t_0, [(((0 + 52 * 5) + 23 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_inc_int8_t_0, [(((0 + 52 * 5) + 24 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_dec_int8_t_0, [(((0 + 52 * 5) + 25 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_bsf_int8_t_0, [(((0 + 52 * 5) + 26 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_bsr_int8_t_0, [(((0 + 52 * 5) + 27 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_int8_t_0, [(((0 + 52 * 5) + 29 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_INT_unary_to_int_int8_t_0, [(((0 + 52 * 5) + 30 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_INT_unary_from_int_int8_t_0, [(((0 + 52 * 5) + 31 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_INT_move_int8_t_0, [(((0 + 52 * 5) + 32 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_INT_copy_int8_t_0, [(((0 + 52 * 5) + 33 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_ldc_int8_t_0, [(((0 + 52 * 5) + 34 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_ldc16_int8_t_0, [(((0 + 52 * 5) + 0 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_add_int16_t_0, [(((0 + 52 * 5) + 1 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_subtract_int16_t_0, [(((0 + 52 * 5) + 2 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_multiply_int16_t_0, [(((0 + 52 * 5) + 3 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_divide_int16_t_0, [(((0 + 52 * 5) + 5 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_modulo_int16_t_0, [(((0 + 52 * 5) + 7 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_power_int16_t_0, [(((0 + 52 * 5) + 8 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_and_int16_t_0, [(((0 + 52 * 5) + 9 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_or_int16_t_0, [(((0 + 52 * 5) + 10 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_xor_int16_t_0, [(((0 + 52 * 5) + 11 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_shl_int16_t_0, [(((0 + 52 * 5) + 12 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_shr_int16_t_0, [(((0 + 52 * 5) + 13 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_bts_int16_t_0, [(((0 + 52 * 5) + 14 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_btr_int16_t_0, [(((0 + 52 * 5) + 15 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_btc_int16_t_0, [(((0 + 52 * 5) + 16 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_equal_int16_t_0, [(((0 + 52 * 5) + 17 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_not_equal_int16_t_0, [(((0 + 52 * 5) + 18 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_less_int16_t_0, [(((0 + 52 * 5) + 19 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_less_equal_int16_t_0, [(((0 + 52 * 5) + 20 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_bt_int16_t_0, [(((0 + 52 * 5) + 21 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_not_int16_t_0, [(((0 + 52 * 5) + 22 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_neg_int16_t_0, [(((0 + 52 * 5) + 23 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_inc_int16_t_0, [(((0 + 52 * 5) + 24 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_dec_int16_t_0, [(((0 + 52 * 5) + 25 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_bsf_int16_t_0, [(((0 + 52 * 5) + 26 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_bsr_int16_t_0, [(((0 + 52 * 5) + 27 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_int16_t_0, [(((0 + 52 * 5) + 29 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_INT_unary_to_int_int16_t_0, [(((0 + 52 * 5) + 30 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_INT_unary_from_int_int16_t_0, [(((0 + 52 * 5) + 31 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_INT_move_int16_t_0, [(((0 + 52 * 5) + 32 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_INT_copy_int16_t_0, [(((0 + 52 * 5) + 33 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_ldc_int16_t_0, [(((0 + 52 * 5) + 34 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_ldc16_int16_t_0, [(((0 + 52 * 5) + 0 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_add_int32_t_0, [(((0 + 52 * 5) + 1 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_subtract_int32_t_0, [(((0 + 52 * 5) + 2 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_multiply_int32_t_0, [(((0 + 52 * 5) + 3 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_divide_int32_t_0, [(((0 + 52 * 5) + 5 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_modulo_int32_t_0, [(((0 + 52 * 5) + 7 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_power_int32_t_0, [(((0 + 52 * 5) + 8 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_and_int32_t_0, [(((0 + 52 * 5) + 9 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_or_int32_t_0, [(((0 + 52 * 5) + 10 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_xor_int32_t_0, [(((0 + 52 * 5) + 11 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_shl_int32_t_0, [(((0 + 52 * 5) + 12 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_shr_int32_t_0, [(((0 + 52 * 5) + 13 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_bts_int32_t_0, [(((0 + 52 * 5) + 14 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_btr_int32_t_0, [(((0 + 52 * 5) + 15 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_btc_int32_t_0, [(((0 + 52 * 5) + 16 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_equal_int32_t_0, [(((0 + 52 * 5) + 17 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_not_equal_int32_t_0, [(((0 + 52 * 5) + 18 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_less_int32_t_0, [(((0 + 52 * 5) + 19 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_less_equal_int32_t_0, [(((0 + 52 * 5) + 20 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_bt_int32_t_0, [(((0 + 52 * 5) + 21 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_not_int32_t_0, [(((0 + 52 * 5) + 22 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_neg_int32_t_0, [(((0 + 52 * 5) + 23 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_inc_int32_t_0, [(((0 + 52 * 5) + 24 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_dec_int32_t_0, [(((0 + 52 * 5) + 25 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_bsf_int32_t_0, [(((0 + 52 * 5) + 26 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_bsr_int32_t_0, [(((0 + 52 * 5) + 27 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_int32_t_0, [(((0 + 52 * 5) + 29 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_INT_unary_to_int_int32_t_0, [(((0 + 52 * 5) + 30 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_INT_unary_from_int_int32_t_0, [(((0 + 52 * 5) + 31 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_INT_move_int32_t_0, [(((0 + 52 * 5) + 32 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_INT_copy_int32_t_0, [(((0 + 52 * 5) + 33 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_ldc_int32_t_0, [(((0 + 52 * 5) + 34 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_ldc16_int32_t_0, [(((0 + 52 * 5) + 0 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_add_int64_t_0, [(((0 + 52 * 5) + 1 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_subtract_int64_t_0, [(((0 + 52 * 5) + 2 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_multiply_int64_t_0, [(((0 + 52 * 5) + 3 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_divide_int64_t_0, [(((0 + 52 * 5) + 5 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_modulo_int64_t_0, [(((0 + 52 * 5) + 7 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_power_int64_t_0, [(((0 + 52 * 5) + 8 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_and_int64_t_0, [(((0 + 52 * 5) + 9 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_or_int64_t_0, [(((0 + 52 * 5) + 10 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_xor_int64_t_0, [(((0 + 52 * 5) + 11 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_shl_int64_t_0, [(((0 + 52 * 5) + 12 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_shr_int64_t_0, [(((0 + 52 * 5) + 13 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_bts_int64_t_0, [(((0 + 52 * 5) + 14 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_btr_int64_t_0, [(((0 + 52 * 5) + 15 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_btc_int64_t_0, [(((0 + 52 * 5) + 16 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_equal_int64_t_0, [(((0 + 52 * 5) + 17 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_not_equal_int64_t_0, [(((0 + 52 * 5) + 18 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_less_int64_t_0, [(((0 + 52 * 5) + 19 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_less_equal_int64_t_0, [(((0 + 52 * 5) + 20 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_bt_int64_t_0, [(((0 + 52 * 5) + 21 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_not_int64_t_0, [(((0 + 52 * 5) + 22 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_neg_int64_t_0, [(((0 + 52 * 5) + 23 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_inc_int64_t_0, [(((0 + 52 * 5) + 24 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_dec_int64_t_0, [(((0 + 52 * 5) + 25 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_bsf_int64_t_0, [(((0 + 52 * 5) + 26 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_bsr_int64_t_0, [(((0 + 52 * 5) + 27 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_int64_t_0, [(((0 + 52 * 5) + 29 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_INT_unary_to_int_int64_t_0, [(((0 + 52 * 5) + 30 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_INT_unary_from_int_int64_t_0, [(((0 + 52 * 5) + 31 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_INT_move_int64_t_0, [(((0 + 52 * 5) + 32 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_INT_copy_int64_t_0, [(((0 + 52 * 5) + 33 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_ldc_int64_t_0, [(((0 + 52 * 5) + 34 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_ldc16_int64_t_0, [(((0 + 52 * 5) + 0 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_add_int128_t_0, [(((0 + 52 * 5) + 1 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_subtract_int128_t_0, [(((0 + 52 * 5) + 2 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_multiply_int128_t_0, [(((0 + 52 * 5) + 3 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_divide_int128_t_0, [(((0 + 52 * 5) + 5 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_modulo_int128_t_0, [(((0 + 52 * 5) + 7 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_power_int128_t_0, [(((0 + 52 * 5) + 8 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_and_int128_t_0, [(((0 + 52 * 5) + 9 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_or_int128_t_0, [(((0 + 52 * 5) + 10 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_xor_int128_t_0, [(((0 + 52 * 5) + 11 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_shl_int128_t_0, [(((0 + 52 * 5) + 12 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_shr_int128_t_0, [(((0 + 52 * 5) + 13 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_bts_int128_t_0, [(((0 + 52 * 5) + 14 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_btr_int128_t_0, [(((0 + 52 * 5) + 15 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_btc_int128_t_0, [(((0 + 52 * 5) + 16 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_equal_int128_t_0, [(((0 + 52 * 5) + 17 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_not_equal_int128_t_0, [(((0 + 52 * 5) + 18 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_less_int128_t_0, [(((0 + 52 * 5) + 19 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_less_equal_int128_t_0, [(((0 + 52 * 5) + 20 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_bt_int128_t_0, [(((0 + 52 * 5) + 21 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_not_int128_t_0, [(((0 + 52 * 5) + 22 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_neg_int128_t_0, [(((0 + 52 * 5) + 23 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_inc_int128_t_0, [(((0 + 52 * 5) + 24 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_dec_int128_t_0, [(((0 + 52 * 5) + 25 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_bsf_int128_t_0, [(((0 + 52 * 5) + 26 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_bsr_int128_t_0, [(((0 + 52 * 5) + 27 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_int128_t_0, [(((0 + 52 * 5) + 29 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_INT_unary_to_int_int128_t_0, [(((0 + 52 * 5) + 30 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_INT_unary_from_int_int128_t_0, [(((0 + 52 * 5) + 31 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_INT_move_int128_t_0, [(((0 + 52 * 5) + 32 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_INT_copy_int128_t_0, [(((0 + 52 * 5) + 33 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_ldc_int128_t_0, [(((0 + 52 * 5) + 34 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_ldc16_int128_t_0,
# 688 "./ipret-1.inc"
# 1 "./for-fix.inc" 1
# 24 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 41 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_alt1_int8_t_0,
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 43 * 1 + 0 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_alt1_int8_t_0,
# 74 "./ipret-a1.inc" 2
# 25 "./for-fix.inc" 2
# 36 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 41 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_alt1_int16_t_0,
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 43 * 1 + 1 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_alt1_int16_t_0,
# 74 "./ipret-a1.inc" 2
# 37 "./for-fix.inc" 2
# 48 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 41 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_alt1_int32_t_0,
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 43 * 1 + 2 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_alt1_int32_t_0,
# 74 "./ipret-a1.inc" 2
# 49 "./for-fix.inc" 2
# 60 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 41 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_alt1_int64_t_0,
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 43 * 1 + 3 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_alt1_int64_t_0,
# 74 "./ipret-a1.inc" 2
# 61 "./for-fix.inc" 2
# 72 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 41 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_alt1_int128_t_0,
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 43 * 1 + 4 * 52) + 0 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_alt1_int128_t_0,
# 74 "./ipret-a1.inc" 2
# 73 "./for-fix.inc" 2
# 689 "./ipret-1.inc" 2


# 1 "./for-int.inc" 1
# 24 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[(((0 + 52 * 5) + 28 * 1 + 0 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_alt1_int8_t_0,
# 38 "./ipret-a2.inc" 2
# 25 "./for-int.inc" 2
# 36 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[(((0 + 52 * 5) + 28 * 1 + 1 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_alt1_int16_t_0,
# 38 "./ipret-a2.inc" 2
# 37 "./for-int.inc" 2
# 48 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[(((0 + 52 * 5) + 28 * 1 + 2 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_alt1_int32_t_0,
# 38 "./ipret-a2.inc" 2
# 49 "./for-int.inc" 2
# 60 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[(((0 + 52 * 5) + 28 * 1 + 3 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_alt1_int64_t_0,
# 38 "./ipret-a2.inc" 2
# 61 "./for-int.inc" 2
# 72 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[(((0 + 52 * 5) + 28 * 1 + 4 * 35) + 0 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_alt1_int128_t_0,
# 38 "./ipret-a2.inc" 2
# 73 "./for-int.inc" 2
# 692 "./ipret-1.inc" 2


# 1 "./for-real.inc" 1
# 23 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 1 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_alt1_real16_t_0,
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 4 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_alt1_real16_t_0,
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 7 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_alt1_real16_t_0,
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 10 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_alt1_real16_t_0,
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 17 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_alt1_real16_t_0,
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 20 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_alt1_real16_t_0,
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 23 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_alt1_real16_t_0,
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 26 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_alt1_real16_t_0,
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 118 "./ipret-a3.inc" 2
# 149 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 64 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_alt1_real16_t_0,
# 150 "./ipret-a3.inc" 2
# 163 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 67 * 1 + 0 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_alt1_real16_t_0,
# 164 "./ipret-a3.inc" 2
# 24 "./for-real.inc" 2
# 33 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 1 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_alt1_real32_t_0,
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 2 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_alt2_real32_t_0,
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 4 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_alt1_real32_t_0,
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 5 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_alt2_real32_t_0,
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 7 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_alt1_real32_t_0,
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 8 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_alt2_real32_t_0,
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 10 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_alt1_real32_t_0,
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 11 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_alt2_real32_t_0,
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 17 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_alt1_real32_t_0,
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 18 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_alt2_real32_t_0,
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 20 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_alt1_real32_t_0,
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 21 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_alt2_real32_t_0,
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 23 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_alt1_real32_t_0,
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 24 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_alt2_real32_t_0,
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 26 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_alt1_real32_t_0,
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 27 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_alt2_real32_t_0,
# 118 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 29 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_alt1_real32_t_0,
# 125 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 30 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_alt2_real32_t_0,
# 131 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 32 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_alt1_real32_t_0,
# 137 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 33 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_alt2_real32_t_0,
# 143 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 64 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_alt1_real32_t_0,
# 150 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 65 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_alt2_real32_t_0,
# 157 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 67 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_alt1_real32_t_0,
# 164 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 68 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_alt2_real32_t_0,
# 171 "./ipret-a3.inc" 2







# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 70 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_alt1_real32_t_0,
# 179 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 71 * 1 + 1 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_alt2_real32_t_0,
# 185 "./ipret-a3.inc" 2
# 34 "./for-real.inc" 2
# 43 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 1 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_alt1_real64_t_0,
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 2 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_alt2_real64_t_0,
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 4 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_alt1_real64_t_0,
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 5 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_alt2_real64_t_0,
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 7 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_alt1_real64_t_0,
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 8 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_alt2_real64_t_0,
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 10 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_alt1_real64_t_0,
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 11 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_alt2_real64_t_0,
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 17 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_alt1_real64_t_0,
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 18 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_alt2_real64_t_0,
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 20 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_alt1_real64_t_0,
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 21 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_alt2_real64_t_0,
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 23 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_alt1_real64_t_0,
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 24 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_alt2_real64_t_0,
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 26 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_alt1_real64_t_0,
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 27 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_alt2_real64_t_0,
# 118 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 29 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_alt1_real64_t_0,
# 125 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 30 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_alt2_real64_t_0,
# 131 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 32 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_alt1_real64_t_0,
# 137 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 33 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_alt2_real64_t_0,
# 143 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 64 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_alt1_real64_t_0,
# 150 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 65 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_alt2_real64_t_0,
# 157 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 67 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_alt1_real64_t_0,
# 164 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 68 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_alt2_real64_t_0,
# 171 "./ipret-a3.inc" 2







# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 70 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_alt1_real64_t_0,
# 179 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 71 * 1 + 2 * 75) + 0 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_alt2_real64_t_0,
# 185 "./ipret-a3.inc" 2
# 44 "./for-real.inc" 2
# 53 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 54 "./for-real.inc" 2
# 695 "./ipret-1.inc" 2
# 748 "./ipret-1.inc"
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 0 * 1) + 0 * OPCODE_MODE_MULT)] = &&label_bool_binary_and_0,
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 1 * 1) + 0 * OPCODE_MODE_MULT)] = &&label_bool_binary_or_0,
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 2 * 1) + 0 * OPCODE_MODE_MULT)] = &&label_bool_binary_equal_0,
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 3 * 1) + 0 * OPCODE_MODE_MULT)] = &&label_bool_binary_not_equal_0,
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 4 * 1) + 0 * OPCODE_MODE_MULT)] = &&label_bool_binary_less_0,
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 5 * 1) + 0 * OPCODE_MODE_MULT)] = &&label_bool_binary_less_equal_0,
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 6 * 1) + 0 * OPCODE_MODE_MULT)] = &&label_bool_unary_not_0,
# 777 "./ipret-1.inc"
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 7) + 0 * OPCODE_MODE_MULT)] = &&label_bool_move_0,





[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 8) + 0 * OPCODE_MODE_MULT)] = &&label_bool_copy_0,






[((OPCODE_INT_LDC_LONG) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_INT_LDC_LONG0,
# 802 "./ipret-1.inc"
[((OPCODE_IS_EXCEPTION) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_IS_EXCEPTION0,
# 822 "./ipret-1.inc"
[((OPCODE_EXCEPTION_CLASS) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_EXCEPTION_CLASS0,
# 833 "./ipret-1.inc"
[((OPCODE_EXCEPTION_TYPE) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_EXCEPTION_TYPE0,
# 844 "./ipret-1.inc"
[((OPCODE_EXCEPTION_AUX) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_EXCEPTION_AUX0,
# 855 "./ipret-1.inc"
[((OPCODE_SYSTEM_PROPERTY) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_SYSTEM_PROPERTY0,
# 867 "./ipret-1.inc"
[((OPCODE_FLAT_MOVE) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_FLAT_MOVE0,
# 881 "./ipret-1.inc"
[((OPCODE_FLAT_COPY) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_FLAT_COPY0,
# 895 "./ipret-1.inc"
[((OPCODE_REF_MOVE) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_REF_MOVE0,
# 906 "./ipret-1.inc"
[((OPCODE_REF_MOVE_CLEAR) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_REF_MOVE_CLEAR0,
# 916 "./ipret-1.inc"
[((OPCODE_REF_COPY) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_REF_COPY0,
# 926 "./ipret-1.inc"
[((OPCODE_BOX_MOVE_CLEAR) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_BOX_MOVE_CLEAR0,
# 937 "./ipret-1.inc"
[((OPCODE_BOX_COPY) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_BOX_COPY0,
# 947 "./ipret-1.inc"
[((OPCODE_TAKE_BORROWED) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_TAKE_BORROWED0,
# 959 "./ipret-1.inc"
[((OPCODE_DEREFERENCE) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_DEREFERENCE0,
# 977 "./ipret-1.inc"
[((OPCODE_DEREFERENCE_CLEAR) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_DEREFERENCE_CLEAR0,
# 994 "./ipret-1.inc"
[((OPCODE_EVAL) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_EVAL0,
# 1017 "./ipret-1.inc"
[((OPCODE_CHECKPOINT) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_CHECKPOINT0,
# 1106 "./ipret-1.inc"
[((OPCODE_JMP) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_JMP0,
# 1124 "./ipret-1.inc"
[((OPCODE_JMP_BACK_16) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_JMP_BACK_160,
# 1134 "./ipret-1.inc"
[((OPCODE_JMP_FALSE) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_JMP_FALSE0,
# 1185 "./ipret-1.inc"
[((OPCODE_LABEL) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_LABEL0,
# 1201 "./ipret-1.inc"
[((OPCODE_LOAD_FN) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_LOAD_FN0,
# 1243 "./ipret-1.inc"
[((OPCODE_CURRY) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_CURRY0,
# 1274 "./ipret-1.inc"
[((OPCODE_CALL) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL0,
# 1349 "./ipret-1.inc"
[((OPCODE_CALL_STRICT) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_STRICT0,






[((OPCODE_CALL_SPARK) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_SPARK0,






[((OPCODE_CALL_INDIRECT) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_INDIRECT0,
# 1423 "./ipret-1.inc"
[((OPCODE_CALL_INDIRECT_STRICT) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_INDIRECT_STRICT0,






[((OPCODE_CALL_INDIRECT_SPARK) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_INDIRECT_SPARK0,






[((OPCODE_CALL_LAZY) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_LAZY0,
# 1496 "./ipret-1.inc"
[((OPCODE_CALL_INDIRECT_LAZY) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_INDIRECT_LAZY0,
# 1514 "./ipret-1.inc"
[((OPCODE_CALL_CACHE) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_CACHE0,
# 1570 "./ipret-1.inc"
[((OPCODE_CALL_SAVE) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_SAVE0,





[((OPCODE_CALL_INDIRECT_CACHE) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_INDIRECT_CACHE0,
# 1672 "./ipret-1.inc"
[((OPCODE_CALL_INDIRECT_SAVE) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_INDIRECT_SAVE0,







[((OPCODE_RETURN) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_RETURN0,
# 1740 "./ipret-1.inc"
[((OPCODE_STRUCTURED) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_STRUCTURED0,
# 1952 "./ipret-1.inc"
[((OPCODE_RECORD_CREATE) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_RECORD_CREATE0,
# 2031 "./ipret-1.inc"
[((OPCODE_RECORD_LOAD) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_RECORD_LOAD0,
# 2085 "./ipret-1.inc"
[((OPCODE_OPTION_CREATE_EMPTY_FLAT) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_CREATE_EMPTY_FLAT0,
# 2097 "./ipret-1.inc"
[((OPCODE_OPTION_CREATE_EMPTY) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_CREATE_EMPTY0,
# 2115 "./ipret-1.inc"
[((OPCODE_OPTION_CREATE) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_CREATE0,
# 2142 "./ipret-1.inc"
[((OPCODE_OPTION_LOAD) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_LOAD0,
# 2188 "./ipret-1.inc"
[((OPCODE_OPTION_TEST_FLAT) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_TEST_FLAT0,
# 2202 "./ipret-1.inc"
[((OPCODE_OPTION_TEST) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_TEST0,
# 2235 "./ipret-1.inc"
[((OPCODE_OPTION_ORD_FLAT) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_ORD_FLAT0,
# 2249 "./ipret-1.inc"
[((OPCODE_OPTION_ORD) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_ORD0,
# 2285 "./ipret-1.inc"
[((OPCODE_ARRAY_CREATE) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_CREATE0,
# 2356 "./ipret-1.inc"
[((OPCODE_ARRAY_CREATE_EMPTY_FLAT) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_CREATE_EMPTY_FLAT0,
# 2370 "./ipret-1.inc"
[((OPCODE_ARRAY_CREATE_EMPTY) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_CREATE_EMPTY0,
# 2382 "./ipret-1.inc"
[((OPCODE_ARRAY_FILL) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_FILL0,
# 2442 "./ipret-1.inc"
[((OPCODE_ARRAY_STRING) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_STRING0,
# 2463 "./ipret-1.inc"
[((OPCODE_ARRAY_UNICODE) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_UNICODE0,
# 2484 "./ipret-1.inc"
[((OPCODE_ARRAY_LOAD) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_LOAD0,
# 2590 "./ipret-1.inc"
[((OPCODE_ARRAY_LEN) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_LEN0,
# 2608 "./ipret-1.inc"
[((OPCODE_ARRAY_LEN_GREATER_THAN) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_LEN_GREATER_THAN0,
# 2627 "./ipret-1.inc"
[((OPCODE_ARRAY_SUB) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_SUB0,
# 2647 "./ipret-1.inc"
[((OPCODE_ARRAY_SKIP) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_SKIP0,
# 2666 "./ipret-1.inc"
[((OPCODE_ARRAY_APPEND) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_APPEND0,
# 2685 "./ipret-1.inc"
[((OPCODE_ARRAY_APPEND_ONE_FLAT) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_APPEND_ONE_FLAT0,
# 2704 "./ipret-1.inc"
[((OPCODE_ARRAY_APPEND_ONE) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_APPEND_ONE0,
# 2723 "./ipret-1.inc"
[((OPCODE_ARRAY_FLATTEN) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_FLATTEN0,
# 2743 "./ipret-1.inc"
[((OPCODE_IO) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_IO0,
# 2764 "./ipret-1.inc"
[((OPCODE_INTERNAL_FUNCTION) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_INTERNAL_FUNCTION0,
# 2775 "./ipret-1.inc"
[((OPCODE_UNREACHABLE) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_UNREACHABLE0,







[((OPCODE_EXIT_THREAD) + 0 * OPCODE_MODE_MULT)] = &&label_OPCODE_EXIT_THREAD0,
# 49 "./ipret.inc" 2






# 1 "./ipret-1.inc" 1
# 317 "./ipret-1.inc"
 [((0 + 0 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_add_int8_t_1, [((0 + 1 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_subtract_int8_t_1, [((0 + 2 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_multiply_int8_t_1, [((0 + 3 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_divide_int8_t_1, [((0 + 5 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_udivide_int8_t_1, [((0 + 7 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_modulo_int8_t_1, [((0 + 9 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_umodulo_int8_t_1, [((0 + 11 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_power_int8_t_1, [((0 + 12 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_and_int8_t_1, [((0 + 13 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_or_int8_t_1, [((0 + 14 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_xor_int8_t_1, [((0 + 15 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shl_int8_t_1, [((0 + 16 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shr_int8_t_1, [((0 + 17 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ushr_int8_t_1, [((0 + 18 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_rol_int8_t_1, [((0 + 19 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ror_int8_t_1, [((0 + 20 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bts_int8_t_1, [((0 + 21 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btr_int8_t_1, [((0 + 22 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btc_int8_t_1, [((0 + 23 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_equal_int8_t_1, [((0 + 24 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_not_equal_int8_t_1, [((0 + 25 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_int8_t_1, [((0 + 26 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_equal_int8_t_1, [((0 + 27 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_int8_t_1, [((0 + 28 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_equal_int8_t_1, [((0 + 29 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bt_int8_t_1, [((0 + 30 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_not_int8_t_1, [((0 + 31 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_neg_int8_t_1, [((0 + 32 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_inc_int8_t_1, [((0 + 33 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_dec_int8_t_1, [((0 + 34 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bswap_int8_t_1, [((0 + 36 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_brev_int8_t_1, [((0 + 38 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsf_int8_t_1, [((0 + 40 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_int8_t_1, [((0 + 42 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_int8_t_1, [((0 + 44 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_to_int_int8_t_1, [((0 + 45 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_uto_int_int8_t_1, [((0 + 46 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_from_int_int8_t_1, [((0 + 47 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_ufrom_int_int8_t_1, [((0 + 48 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_move_int8_t_1, [((0 + 49 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_copy_int8_t_1, [((0 + 50 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_int8_t_1, [((0 + 0 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_add_int16_t_1, [((0 + 1 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_subtract_int16_t_1, [((0 + 2 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_multiply_int16_t_1, [((0 + 3 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_divide_int16_t_1, [((0 + 5 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_udivide_int16_t_1, [((0 + 7 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_modulo_int16_t_1, [((0 + 9 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_umodulo_int16_t_1, [((0 + 11 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_power_int16_t_1, [((0 + 12 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_and_int16_t_1, [((0 + 13 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_or_int16_t_1, [((0 + 14 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_xor_int16_t_1, [((0 + 15 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shl_int16_t_1, [((0 + 16 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shr_int16_t_1, [((0 + 17 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ushr_int16_t_1, [((0 + 18 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_rol_int16_t_1, [((0 + 19 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ror_int16_t_1, [((0 + 20 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bts_int16_t_1, [((0 + 21 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btr_int16_t_1, [((0 + 22 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btc_int16_t_1, [((0 + 23 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_equal_int16_t_1, [((0 + 24 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_not_equal_int16_t_1, [((0 + 25 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_int16_t_1, [((0 + 26 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_equal_int16_t_1, [((0 + 27 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_int16_t_1, [((0 + 28 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_equal_int16_t_1, [((0 + 29 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bt_int16_t_1, [((0 + 30 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_not_int16_t_1, [((0 + 31 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_neg_int16_t_1, [((0 + 32 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_inc_int16_t_1, [((0 + 33 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_dec_int16_t_1, [((0 + 34 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bswap_int16_t_1, [((0 + 36 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_brev_int16_t_1, [((0 + 38 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsf_int16_t_1, [((0 + 40 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_int16_t_1, [((0 + 42 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_int16_t_1, [((0 + 44 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_to_int_int16_t_1, [((0 + 45 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_uto_int_int16_t_1, [((0 + 46 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_from_int_int16_t_1, [((0 + 47 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_ufrom_int_int16_t_1, [((0 + 48 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_move_int16_t_1, [((0 + 49 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_copy_int16_t_1, [((0 + 50 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_int16_t_1, [((0 + 0 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_add_int32_t_1, [((0 + 1 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_subtract_int32_t_1, [((0 + 2 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_multiply_int32_t_1, [((0 + 3 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_divide_int32_t_1, [((0 + 5 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_udivide_int32_t_1, [((0 + 7 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_modulo_int32_t_1, [((0 + 9 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_umodulo_int32_t_1, [((0 + 11 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_power_int32_t_1, [((0 + 12 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_and_int32_t_1, [((0 + 13 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_or_int32_t_1, [((0 + 14 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_xor_int32_t_1, [((0 + 15 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shl_int32_t_1, [((0 + 16 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shr_int32_t_1, [((0 + 17 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ushr_int32_t_1, [((0 + 18 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_rol_int32_t_1, [((0 + 19 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ror_int32_t_1, [((0 + 20 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bts_int32_t_1, [((0 + 21 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btr_int32_t_1, [((0 + 22 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btc_int32_t_1, [((0 + 23 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_equal_int32_t_1, [((0 + 24 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_not_equal_int32_t_1, [((0 + 25 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_int32_t_1, [((0 + 26 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_equal_int32_t_1, [((0 + 27 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_int32_t_1, [((0 + 28 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_equal_int32_t_1, [((0 + 29 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bt_int32_t_1, [((0 + 30 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_not_int32_t_1, [((0 + 31 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_neg_int32_t_1, [((0 + 32 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_inc_int32_t_1, [((0 + 33 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_dec_int32_t_1, [((0 + 34 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bswap_int32_t_1, [((0 + 36 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_brev_int32_t_1, [((0 + 38 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsf_int32_t_1, [((0 + 40 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_int32_t_1, [((0 + 42 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_int32_t_1, [((0 + 44 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_to_int_int32_t_1, [((0 + 45 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_uto_int_int32_t_1, [((0 + 46 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_from_int_int32_t_1, [((0 + 47 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_ufrom_int_int32_t_1, [((0 + 48 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_move_int32_t_1, [((0 + 49 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_copy_int32_t_1, [((0 + 50 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_int32_t_1, [((0 + 0 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_add_int64_t_1, [((0 + 1 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_subtract_int64_t_1, [((0 + 2 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_multiply_int64_t_1, [((0 + 3 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_divide_int64_t_1, [((0 + 5 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_udivide_int64_t_1, [((0 + 7 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_modulo_int64_t_1, [((0 + 9 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_umodulo_int64_t_1, [((0 + 11 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_power_int64_t_1, [((0 + 12 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_and_int64_t_1, [((0 + 13 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_or_int64_t_1, [((0 + 14 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_xor_int64_t_1, [((0 + 15 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shl_int64_t_1, [((0 + 16 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shr_int64_t_1, [((0 + 17 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ushr_int64_t_1, [((0 + 18 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_rol_int64_t_1, [((0 + 19 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ror_int64_t_1, [((0 + 20 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bts_int64_t_1, [((0 + 21 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btr_int64_t_1, [((0 + 22 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btc_int64_t_1, [((0 + 23 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_equal_int64_t_1, [((0 + 24 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_not_equal_int64_t_1, [((0 + 25 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_int64_t_1, [((0 + 26 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_equal_int64_t_1, [((0 + 27 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_int64_t_1, [((0 + 28 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_equal_int64_t_1, [((0 + 29 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bt_int64_t_1, [((0 + 30 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_not_int64_t_1, [((0 + 31 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_neg_int64_t_1, [((0 + 32 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_inc_int64_t_1, [((0 + 33 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_dec_int64_t_1, [((0 + 34 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bswap_int64_t_1, [((0 + 36 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_brev_int64_t_1, [((0 + 38 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsf_int64_t_1, [((0 + 40 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_int64_t_1, [((0 + 42 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_int64_t_1, [((0 + 44 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_to_int_int64_t_1, [((0 + 45 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_uto_int_int64_t_1, [((0 + 46 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_from_int_int64_t_1, [((0 + 47 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_ufrom_int_int64_t_1, [((0 + 48 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_move_int64_t_1, [((0 + 49 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_copy_int64_t_1, [((0 + 50 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_int64_t_1, [((0 + 0 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_add_int128_t_1, [((0 + 1 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_subtract_int128_t_1, [((0 + 2 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_multiply_int128_t_1, [((0 + 3 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_divide_int128_t_1, [((0 + 5 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_udivide_int128_t_1, [((0 + 7 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_modulo_int128_t_1, [((0 + 9 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_umodulo_int128_t_1, [((0 + 11 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_power_int128_t_1, [((0 + 12 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_and_int128_t_1, [((0 + 13 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_or_int128_t_1, [((0 + 14 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_xor_int128_t_1, [((0 + 15 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shl_int128_t_1, [((0 + 16 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shr_int128_t_1, [((0 + 17 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ushr_int128_t_1, [((0 + 18 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_rol_int128_t_1, [((0 + 19 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ror_int128_t_1, [((0 + 20 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bts_int128_t_1, [((0 + 21 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btr_int128_t_1, [((0 + 22 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btc_int128_t_1, [((0 + 23 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_equal_int128_t_1, [((0 + 24 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_not_equal_int128_t_1, [((0 + 25 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_int128_t_1, [((0 + 26 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_equal_int128_t_1, [((0 + 27 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_int128_t_1, [((0 + 28 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_equal_int128_t_1, [((0 + 29 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bt_int128_t_1, [((0 + 30 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_not_int128_t_1, [((0 + 31 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_neg_int128_t_1, [((0 + 32 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_inc_int128_t_1, [((0 + 33 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_dec_int128_t_1, [((0 + 34 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bswap_int128_t_1, [((0 + 36 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_brev_int128_t_1, [((0 + 38 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsf_int128_t_1, [((0 + 40 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_int128_t_1, [((0 + 42 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_int128_t_1, [((0 + 44 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_to_int_int128_t_1, [((0 + 45 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_uto_int_int128_t_1, [((0 + 46 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_from_int_int128_t_1, [((0 + 47 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_ufrom_int_int128_t_1, [((0 + 48 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_move_int128_t_1, [((0 + 49 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_copy_int128_t_1, [((0 + 50 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_int128_t_1,


[((0 + 51 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_fixed_ldc16_int32_t_1,

[((0 + 51 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_fixed_ldc16_int64_t_1,

[((0 + 51 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_fixed_ldc16_int128_t_1,
# 420 "./ipret-1.inc"
 [((((0 + 52 * 5) + 35 * 5) + 0 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 3 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 6 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 9 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 12 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_modulo_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 13 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_power_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 14 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_ldexp_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 15 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_atan2_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 16 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 19 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 22 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 25 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 28 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 31 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 35 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cbrt_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 36 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sin_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 37 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cos_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 38 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tan_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 39 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asin_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 40 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acos_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 41 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atan_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 42 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sinh_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 43 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cosh_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 44 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tanh_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 45 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asinh_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 46 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acosh_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 47 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atanh_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 48 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp2_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 49 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 50 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp10_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 51 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log2_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 52 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 53 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log10_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 54 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_round_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 56 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_ceil_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 55 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_floor_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 57 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_trunc_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 58 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_fract_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 59 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_mantissa_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 60 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exponent_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 61 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_next_number_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 62 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_prev_number_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 63 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 66 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 69 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 72 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_move_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 73 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_copy_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 74 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_real16_t_1, [((((0 + 52 * 5) + 35 * 5) + 0 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 3 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 6 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 9 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 12 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_modulo_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 13 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_power_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 14 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_ldexp_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 15 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_atan2_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 16 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 19 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 22 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 25 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 28 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 31 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 35 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cbrt_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 36 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sin_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 37 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cos_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 38 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tan_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 39 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asin_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 40 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acos_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 41 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atan_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 42 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sinh_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 43 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cosh_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 44 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tanh_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 45 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asinh_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 46 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acosh_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 47 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atanh_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 48 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp2_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 49 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 50 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp10_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 51 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log2_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 52 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 53 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log10_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 54 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_round_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 56 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_ceil_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 55 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_floor_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 57 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_trunc_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 58 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_fract_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 59 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_mantissa_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 60 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exponent_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 61 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_next_number_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 62 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_prev_number_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 63 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 66 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 69 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 72 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_move_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 73 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_copy_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 74 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_real32_t_1, [((((0 + 52 * 5) + 35 * 5) + 0 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 3 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 6 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 9 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 12 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_modulo_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 13 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_power_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 14 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_ldexp_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 15 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_atan2_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 16 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 19 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 22 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 25 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 28 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 31 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 35 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cbrt_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 36 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sin_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 37 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cos_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 38 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tan_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 39 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asin_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 40 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acos_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 41 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atan_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 42 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sinh_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 43 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cosh_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 44 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tanh_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 45 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asinh_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 46 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acosh_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 47 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atanh_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 48 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp2_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 49 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 50 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp10_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 51 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log2_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 52 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 53 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log10_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 54 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_round_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 56 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_ceil_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 55 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_floor_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 57 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_trunc_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 58 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_fract_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 59 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_mantissa_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 60 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exponent_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 61 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_next_number_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 62 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_prev_number_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 63 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 66 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 69 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 72 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_move_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 73 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_copy_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 74 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_real64_t_1, [((((0 + 52 * 5) + 35 * 5) + 0 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 3 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 6 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 9 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 12 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_modulo_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 13 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_power_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 14 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_ldexp_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 15 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_atan2_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 16 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 19 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 22 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 25 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 28 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 31 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 35 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cbrt_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 36 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sin_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 37 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cos_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 38 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tan_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 39 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asin_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 40 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acos_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 41 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atan_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 42 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sinh_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 43 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cosh_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 44 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tanh_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 45 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asinh_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 46 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acosh_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 47 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atanh_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 48 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp2_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 49 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 50 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp10_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 51 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log2_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 52 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 53 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log10_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 54 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_round_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 56 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_ceil_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 55 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_floor_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 57 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_trunc_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 58 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_fract_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 59 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_mantissa_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 60 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exponent_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 61 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_next_number_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 62 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_prev_number_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 63 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 66 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 69 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 72 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_move_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 73 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_copy_real80_t_1, [((((0 + 52 * 5) + 35 * 5) + 74 * 1 + 3 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_real80_t_1,
# 655 "./ipret-1.inc"
[(((0 + 52 * 5) + 0 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_add_int8_t_1, [(((0 + 52 * 5) + 1 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_subtract_int8_t_1, [(((0 + 52 * 5) + 2 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_multiply_int8_t_1, [(((0 + 52 * 5) + 3 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_divide_int8_t_1, [(((0 + 52 * 5) + 5 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_modulo_int8_t_1, [(((0 + 52 * 5) + 7 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_power_int8_t_1, [(((0 + 52 * 5) + 8 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_and_int8_t_1, [(((0 + 52 * 5) + 9 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_or_int8_t_1, [(((0 + 52 * 5) + 10 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_xor_int8_t_1, [(((0 + 52 * 5) + 11 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_shl_int8_t_1, [(((0 + 52 * 5) + 12 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_shr_int8_t_1, [(((0 + 52 * 5) + 13 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_bts_int8_t_1, [(((0 + 52 * 5) + 14 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_btr_int8_t_1, [(((0 + 52 * 5) + 15 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_btc_int8_t_1, [(((0 + 52 * 5) + 16 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_equal_int8_t_1, [(((0 + 52 * 5) + 17 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_not_equal_int8_t_1, [(((0 + 52 * 5) + 18 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_less_int8_t_1, [(((0 + 52 * 5) + 19 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_less_equal_int8_t_1, [(((0 + 52 * 5) + 20 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_bt_int8_t_1, [(((0 + 52 * 5) + 21 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_not_int8_t_1, [(((0 + 52 * 5) + 22 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_neg_int8_t_1, [(((0 + 52 * 5) + 23 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_inc_int8_t_1, [(((0 + 52 * 5) + 24 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_dec_int8_t_1, [(((0 + 52 * 5) + 25 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_bsf_int8_t_1, [(((0 + 52 * 5) + 26 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_bsr_int8_t_1, [(((0 + 52 * 5) + 27 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_int8_t_1, [(((0 + 52 * 5) + 29 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_INT_unary_to_int_int8_t_1, [(((0 + 52 * 5) + 30 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_INT_unary_from_int_int8_t_1, [(((0 + 52 * 5) + 31 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_INT_move_int8_t_1, [(((0 + 52 * 5) + 32 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_INT_copy_int8_t_1, [(((0 + 52 * 5) + 33 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_ldc_int8_t_1, [(((0 + 52 * 5) + 34 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_ldc16_int8_t_1, [(((0 + 52 * 5) + 0 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_add_int16_t_1, [(((0 + 52 * 5) + 1 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_subtract_int16_t_1, [(((0 + 52 * 5) + 2 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_multiply_int16_t_1, [(((0 + 52 * 5) + 3 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_divide_int16_t_1, [(((0 + 52 * 5) + 5 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_modulo_int16_t_1, [(((0 + 52 * 5) + 7 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_power_int16_t_1, [(((0 + 52 * 5) + 8 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_and_int16_t_1, [(((0 + 52 * 5) + 9 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_or_int16_t_1, [(((0 + 52 * 5) + 10 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_xor_int16_t_1, [(((0 + 52 * 5) + 11 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_shl_int16_t_1, [(((0 + 52 * 5) + 12 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_shr_int16_t_1, [(((0 + 52 * 5) + 13 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_bts_int16_t_1, [(((0 + 52 * 5) + 14 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_btr_int16_t_1, [(((0 + 52 * 5) + 15 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_btc_int16_t_1, [(((0 + 52 * 5) + 16 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_equal_int16_t_1, [(((0 + 52 * 5) + 17 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_not_equal_int16_t_1, [(((0 + 52 * 5) + 18 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_less_int16_t_1, [(((0 + 52 * 5) + 19 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_less_equal_int16_t_1, [(((0 + 52 * 5) + 20 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_bt_int16_t_1, [(((0 + 52 * 5) + 21 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_not_int16_t_1, [(((0 + 52 * 5) + 22 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_neg_int16_t_1, [(((0 + 52 * 5) + 23 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_inc_int16_t_1, [(((0 + 52 * 5) + 24 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_dec_int16_t_1, [(((0 + 52 * 5) + 25 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_bsf_int16_t_1, [(((0 + 52 * 5) + 26 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_bsr_int16_t_1, [(((0 + 52 * 5) + 27 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_int16_t_1, [(((0 + 52 * 5) + 29 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_INT_unary_to_int_int16_t_1, [(((0 + 52 * 5) + 30 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_INT_unary_from_int_int16_t_1, [(((0 + 52 * 5) + 31 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_INT_move_int16_t_1, [(((0 + 52 * 5) + 32 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_INT_copy_int16_t_1, [(((0 + 52 * 5) + 33 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_ldc_int16_t_1, [(((0 + 52 * 5) + 34 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_ldc16_int16_t_1, [(((0 + 52 * 5) + 0 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_add_int32_t_1, [(((0 + 52 * 5) + 1 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_subtract_int32_t_1, [(((0 + 52 * 5) + 2 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_multiply_int32_t_1, [(((0 + 52 * 5) + 3 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_divide_int32_t_1, [(((0 + 52 * 5) + 5 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_modulo_int32_t_1, [(((0 + 52 * 5) + 7 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_power_int32_t_1, [(((0 + 52 * 5) + 8 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_and_int32_t_1, [(((0 + 52 * 5) + 9 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_or_int32_t_1, [(((0 + 52 * 5) + 10 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_xor_int32_t_1, [(((0 + 52 * 5) + 11 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_shl_int32_t_1, [(((0 + 52 * 5) + 12 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_shr_int32_t_1, [(((0 + 52 * 5) + 13 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_bts_int32_t_1, [(((0 + 52 * 5) + 14 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_btr_int32_t_1, [(((0 + 52 * 5) + 15 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_btc_int32_t_1, [(((0 + 52 * 5) + 16 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_equal_int32_t_1, [(((0 + 52 * 5) + 17 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_not_equal_int32_t_1, [(((0 + 52 * 5) + 18 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_less_int32_t_1, [(((0 + 52 * 5) + 19 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_less_equal_int32_t_1, [(((0 + 52 * 5) + 20 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_bt_int32_t_1, [(((0 + 52 * 5) + 21 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_not_int32_t_1, [(((0 + 52 * 5) + 22 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_neg_int32_t_1, [(((0 + 52 * 5) + 23 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_inc_int32_t_1, [(((0 + 52 * 5) + 24 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_dec_int32_t_1, [(((0 + 52 * 5) + 25 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_bsf_int32_t_1, [(((0 + 52 * 5) + 26 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_bsr_int32_t_1, [(((0 + 52 * 5) + 27 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_int32_t_1, [(((0 + 52 * 5) + 29 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_INT_unary_to_int_int32_t_1, [(((0 + 52 * 5) + 30 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_INT_unary_from_int_int32_t_1, [(((0 + 52 * 5) + 31 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_INT_move_int32_t_1, [(((0 + 52 * 5) + 32 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_INT_copy_int32_t_1, [(((0 + 52 * 5) + 33 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_ldc_int32_t_1, [(((0 + 52 * 5) + 34 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_ldc16_int32_t_1, [(((0 + 52 * 5) + 0 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_add_int64_t_1, [(((0 + 52 * 5) + 1 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_subtract_int64_t_1, [(((0 + 52 * 5) + 2 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_multiply_int64_t_1, [(((0 + 52 * 5) + 3 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_divide_int64_t_1, [(((0 + 52 * 5) + 5 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_modulo_int64_t_1, [(((0 + 52 * 5) + 7 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_power_int64_t_1, [(((0 + 52 * 5) + 8 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_and_int64_t_1, [(((0 + 52 * 5) + 9 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_or_int64_t_1, [(((0 + 52 * 5) + 10 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_xor_int64_t_1, [(((0 + 52 * 5) + 11 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_shl_int64_t_1, [(((0 + 52 * 5) + 12 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_shr_int64_t_1, [(((0 + 52 * 5) + 13 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_bts_int64_t_1, [(((0 + 52 * 5) + 14 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_btr_int64_t_1, [(((0 + 52 * 5) + 15 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_btc_int64_t_1, [(((0 + 52 * 5) + 16 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_equal_int64_t_1, [(((0 + 52 * 5) + 17 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_not_equal_int64_t_1, [(((0 + 52 * 5) + 18 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_less_int64_t_1, [(((0 + 52 * 5) + 19 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_less_equal_int64_t_1, [(((0 + 52 * 5) + 20 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_bt_int64_t_1, [(((0 + 52 * 5) + 21 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_not_int64_t_1, [(((0 + 52 * 5) + 22 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_neg_int64_t_1, [(((0 + 52 * 5) + 23 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_inc_int64_t_1, [(((0 + 52 * 5) + 24 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_dec_int64_t_1, [(((0 + 52 * 5) + 25 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_bsf_int64_t_1, [(((0 + 52 * 5) + 26 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_bsr_int64_t_1, [(((0 + 52 * 5) + 27 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_int64_t_1, [(((0 + 52 * 5) + 29 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_INT_unary_to_int_int64_t_1, [(((0 + 52 * 5) + 30 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_INT_unary_from_int_int64_t_1, [(((0 + 52 * 5) + 31 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_INT_move_int64_t_1, [(((0 + 52 * 5) + 32 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_INT_copy_int64_t_1, [(((0 + 52 * 5) + 33 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_ldc_int64_t_1, [(((0 + 52 * 5) + 34 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_ldc16_int64_t_1, [(((0 + 52 * 5) + 0 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_add_int128_t_1, [(((0 + 52 * 5) + 1 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_subtract_int128_t_1, [(((0 + 52 * 5) + 2 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_multiply_int128_t_1, [(((0 + 52 * 5) + 3 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_divide_int128_t_1, [(((0 + 52 * 5) + 5 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_modulo_int128_t_1, [(((0 + 52 * 5) + 7 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_power_int128_t_1, [(((0 + 52 * 5) + 8 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_and_int128_t_1, [(((0 + 52 * 5) + 9 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_or_int128_t_1, [(((0 + 52 * 5) + 10 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_xor_int128_t_1, [(((0 + 52 * 5) + 11 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_shl_int128_t_1, [(((0 + 52 * 5) + 12 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_shr_int128_t_1, [(((0 + 52 * 5) + 13 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_bts_int128_t_1, [(((0 + 52 * 5) + 14 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_btr_int128_t_1, [(((0 + 52 * 5) + 15 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_btc_int128_t_1, [(((0 + 52 * 5) + 16 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_equal_int128_t_1, [(((0 + 52 * 5) + 17 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_not_equal_int128_t_1, [(((0 + 52 * 5) + 18 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_less_int128_t_1, [(((0 + 52 * 5) + 19 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_less_equal_int128_t_1, [(((0 + 52 * 5) + 20 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_bt_int128_t_1, [(((0 + 52 * 5) + 21 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_not_int128_t_1, [(((0 + 52 * 5) + 22 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_neg_int128_t_1, [(((0 + 52 * 5) + 23 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_inc_int128_t_1, [(((0 + 52 * 5) + 24 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_dec_int128_t_1, [(((0 + 52 * 5) + 25 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_bsf_int128_t_1, [(((0 + 52 * 5) + 26 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_bsr_int128_t_1, [(((0 + 52 * 5) + 27 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_int128_t_1, [(((0 + 52 * 5) + 29 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_INT_unary_to_int_int128_t_1, [(((0 + 52 * 5) + 30 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_INT_unary_from_int_int128_t_1, [(((0 + 52 * 5) + 31 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_INT_move_int128_t_1, [(((0 + 52 * 5) + 32 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_INT_copy_int128_t_1, [(((0 + 52 * 5) + 33 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_ldc_int128_t_1, [(((0 + 52 * 5) + 34 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_ldc16_int128_t_1,
# 688 "./ipret-1.inc"
# 1 "./for-fix.inc" 1
# 24 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 41 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_alt1_int8_t_1,
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 43 * 1 + 0 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_alt1_int8_t_1,
# 74 "./ipret-a1.inc" 2
# 25 "./for-fix.inc" 2
# 36 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 41 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_alt1_int16_t_1,
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 43 * 1 + 1 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_alt1_int16_t_1,
# 74 "./ipret-a1.inc" 2
# 37 "./for-fix.inc" 2
# 48 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 41 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_alt1_int32_t_1,
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 43 * 1 + 2 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_alt1_int32_t_1,
# 74 "./ipret-a1.inc" 2
# 49 "./for-fix.inc" 2
# 60 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 41 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_alt1_int64_t_1,
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 43 * 1 + 3 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_alt1_int64_t_1,
# 74 "./ipret-a1.inc" 2
# 61 "./for-fix.inc" 2
# 72 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 41 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_alt1_int128_t_1,
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 43 * 1 + 4 * 52) + 1 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_alt1_int128_t_1,
# 74 "./ipret-a1.inc" 2
# 73 "./for-fix.inc" 2
# 689 "./ipret-1.inc" 2


# 1 "./for-int.inc" 1
# 24 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[(((0 + 52 * 5) + 28 * 1 + 0 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_alt1_int8_t_1,
# 38 "./ipret-a2.inc" 2
# 25 "./for-int.inc" 2
# 36 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[(((0 + 52 * 5) + 28 * 1 + 1 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_alt1_int16_t_1,
# 38 "./ipret-a2.inc" 2
# 37 "./for-int.inc" 2
# 48 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[(((0 + 52 * 5) + 28 * 1 + 2 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_alt1_int32_t_1,
# 38 "./ipret-a2.inc" 2
# 49 "./for-int.inc" 2
# 60 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[(((0 + 52 * 5) + 28 * 1 + 3 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_alt1_int64_t_1,
# 38 "./ipret-a2.inc" 2
# 61 "./for-int.inc" 2
# 72 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[(((0 + 52 * 5) + 28 * 1 + 4 * 35) + 1 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_alt1_int128_t_1,
# 38 "./ipret-a2.inc" 2
# 73 "./for-int.inc" 2
# 692 "./ipret-1.inc" 2


# 1 "./for-real.inc" 1
# 23 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 1 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_alt1_real16_t_1,
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 4 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_alt1_real16_t_1,
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 7 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_alt1_real16_t_1,
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 10 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_alt1_real16_t_1,
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 17 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_alt1_real16_t_1,
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 20 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_alt1_real16_t_1,
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 23 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_alt1_real16_t_1,
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 26 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_alt1_real16_t_1,
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 118 "./ipret-a3.inc" 2
# 149 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 64 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_alt1_real16_t_1,
# 150 "./ipret-a3.inc" 2
# 163 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 67 * 1 + 0 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_alt1_real16_t_1,
# 164 "./ipret-a3.inc" 2
# 24 "./for-real.inc" 2
# 33 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 1 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_alt1_real32_t_1,
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 2 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_alt2_real32_t_1,
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 4 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_alt1_real32_t_1,
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 5 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_alt2_real32_t_1,
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 7 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_alt1_real32_t_1,
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 8 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_alt2_real32_t_1,
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 10 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_alt1_real32_t_1,
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 11 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_alt2_real32_t_1,
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 17 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_alt1_real32_t_1,
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 18 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_alt2_real32_t_1,
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 20 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_alt1_real32_t_1,
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 21 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_alt2_real32_t_1,
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 23 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_alt1_real32_t_1,
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 24 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_alt2_real32_t_1,
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 26 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_alt1_real32_t_1,
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 27 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_alt2_real32_t_1,
# 118 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 29 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_alt1_real32_t_1,
# 125 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 30 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_alt2_real32_t_1,
# 131 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 32 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_alt1_real32_t_1,
# 137 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 33 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_alt2_real32_t_1,
# 143 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 64 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_alt1_real32_t_1,
# 150 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 65 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_alt2_real32_t_1,
# 157 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 67 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_alt1_real32_t_1,
# 164 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 68 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_alt2_real32_t_1,
# 171 "./ipret-a3.inc" 2







# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 70 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_alt1_real32_t_1,
# 179 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 71 * 1 + 1 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_alt2_real32_t_1,
# 185 "./ipret-a3.inc" 2
# 34 "./for-real.inc" 2
# 43 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 1 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_alt1_real64_t_1,
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 2 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_alt2_real64_t_1,
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 4 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_alt1_real64_t_1,
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 5 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_alt2_real64_t_1,
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 7 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_alt1_real64_t_1,
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 8 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_alt2_real64_t_1,
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 10 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_alt1_real64_t_1,
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 11 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_alt2_real64_t_1,
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 17 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_alt1_real64_t_1,
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 18 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_alt2_real64_t_1,
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 20 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_alt1_real64_t_1,
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 21 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_alt2_real64_t_1,
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 23 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_alt1_real64_t_1,
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 24 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_alt2_real64_t_1,
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 26 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_alt1_real64_t_1,
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 27 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_alt2_real64_t_1,
# 118 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 29 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_alt1_real64_t_1,
# 125 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 30 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_alt2_real64_t_1,
# 131 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 32 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_alt1_real64_t_1,
# 137 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 33 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_alt2_real64_t_1,
# 143 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 64 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_alt1_real64_t_1,
# 150 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 65 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_alt2_real64_t_1,
# 157 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 67 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_alt1_real64_t_1,
# 164 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 68 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_alt2_real64_t_1,
# 171 "./ipret-a3.inc" 2







# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 70 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_alt1_real64_t_1,
# 179 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 71 * 1 + 2 * 75) + 1 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_alt2_real64_t_1,
# 185 "./ipret-a3.inc" 2
# 44 "./for-real.inc" 2
# 53 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 54 "./for-real.inc" 2
# 695 "./ipret-1.inc" 2
# 748 "./ipret-1.inc"
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 0 * 1) + 1 * OPCODE_MODE_MULT)] = &&label_bool_binary_and_1,
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 1 * 1) + 1 * OPCODE_MODE_MULT)] = &&label_bool_binary_or_1,
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 2 * 1) + 1 * OPCODE_MODE_MULT)] = &&label_bool_binary_equal_1,
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 3 * 1) + 1 * OPCODE_MODE_MULT)] = &&label_bool_binary_not_equal_1,
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 4 * 1) + 1 * OPCODE_MODE_MULT)] = &&label_bool_binary_less_1,
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 5 * 1) + 1 * OPCODE_MODE_MULT)] = &&label_bool_binary_less_equal_1,
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 6 * 1) + 1 * OPCODE_MODE_MULT)] = &&label_bool_unary_not_1,
# 777 "./ipret-1.inc"
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 7) + 1 * OPCODE_MODE_MULT)] = &&label_bool_move_1,





[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 8) + 1 * OPCODE_MODE_MULT)] = &&label_bool_copy_1,






[((OPCODE_INT_LDC_LONG) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_INT_LDC_LONG1,
# 802 "./ipret-1.inc"
[((OPCODE_IS_EXCEPTION) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_IS_EXCEPTION1,
# 822 "./ipret-1.inc"
[((OPCODE_EXCEPTION_CLASS) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_EXCEPTION_CLASS1,
# 833 "./ipret-1.inc"
[((OPCODE_EXCEPTION_TYPE) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_EXCEPTION_TYPE1,
# 844 "./ipret-1.inc"
[((OPCODE_EXCEPTION_AUX) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_EXCEPTION_AUX1,
# 855 "./ipret-1.inc"
[((OPCODE_SYSTEM_PROPERTY) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_SYSTEM_PROPERTY1,
# 867 "./ipret-1.inc"
[((OPCODE_FLAT_MOVE) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_FLAT_MOVE1,
# 881 "./ipret-1.inc"
[((OPCODE_FLAT_COPY) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_FLAT_COPY1,
# 895 "./ipret-1.inc"
[((OPCODE_REF_MOVE) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_REF_MOVE1,
# 906 "./ipret-1.inc"
[((OPCODE_REF_MOVE_CLEAR) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_REF_MOVE_CLEAR1,
# 916 "./ipret-1.inc"
[((OPCODE_REF_COPY) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_REF_COPY1,
# 926 "./ipret-1.inc"
[((OPCODE_BOX_MOVE_CLEAR) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_BOX_MOVE_CLEAR1,
# 937 "./ipret-1.inc"
[((OPCODE_BOX_COPY) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_BOX_COPY1,
# 947 "./ipret-1.inc"
[((OPCODE_TAKE_BORROWED) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_TAKE_BORROWED1,
# 959 "./ipret-1.inc"
[((OPCODE_DEREFERENCE) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_DEREFERENCE1,
# 977 "./ipret-1.inc"
[((OPCODE_DEREFERENCE_CLEAR) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_DEREFERENCE_CLEAR1,
# 994 "./ipret-1.inc"
[((OPCODE_EVAL) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_EVAL1,
# 1017 "./ipret-1.inc"
[((OPCODE_CHECKPOINT) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_CHECKPOINT1,
# 1134 "./ipret-1.inc"
[((OPCODE_JMP_FALSE) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_JMP_FALSE1,
# 1201 "./ipret-1.inc"
[((OPCODE_LOAD_FN) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_LOAD_FN1,
# 1243 "./ipret-1.inc"
[((OPCODE_CURRY) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_CURRY1,
# 1274 "./ipret-1.inc"
[((OPCODE_CALL) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL1,
# 1349 "./ipret-1.inc"
[((OPCODE_CALL_STRICT) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_STRICT1,






[((OPCODE_CALL_SPARK) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_SPARK1,






[((OPCODE_CALL_INDIRECT) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_INDIRECT1,
# 1423 "./ipret-1.inc"
[((OPCODE_CALL_INDIRECT_STRICT) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_INDIRECT_STRICT1,






[((OPCODE_CALL_INDIRECT_SPARK) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_INDIRECT_SPARK1,






[((OPCODE_CALL_LAZY) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_LAZY1,
# 1496 "./ipret-1.inc"
[((OPCODE_CALL_INDIRECT_LAZY) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_INDIRECT_LAZY1,
# 1514 "./ipret-1.inc"
[((OPCODE_CALL_CACHE) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_CACHE1,
# 1570 "./ipret-1.inc"
[((OPCODE_CALL_SAVE) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_SAVE1,





[((OPCODE_CALL_INDIRECT_CACHE) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_INDIRECT_CACHE1,
# 1672 "./ipret-1.inc"
[((OPCODE_CALL_INDIRECT_SAVE) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_INDIRECT_SAVE1,







[((OPCODE_RETURN) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_RETURN1,
# 1740 "./ipret-1.inc"
[((OPCODE_STRUCTURED) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_STRUCTURED1,
# 1952 "./ipret-1.inc"
[((OPCODE_RECORD_CREATE) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_RECORD_CREATE1,
# 2031 "./ipret-1.inc"
[((OPCODE_RECORD_LOAD) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_RECORD_LOAD1,
# 2085 "./ipret-1.inc"
[((OPCODE_OPTION_CREATE_EMPTY_FLAT) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_CREATE_EMPTY_FLAT1,
# 2097 "./ipret-1.inc"
[((OPCODE_OPTION_CREATE_EMPTY) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_CREATE_EMPTY1,
# 2115 "./ipret-1.inc"
[((OPCODE_OPTION_CREATE) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_CREATE1,
# 2142 "./ipret-1.inc"
[((OPCODE_OPTION_LOAD) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_LOAD1,
# 2188 "./ipret-1.inc"
[((OPCODE_OPTION_TEST_FLAT) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_TEST_FLAT1,
# 2202 "./ipret-1.inc"
[((OPCODE_OPTION_TEST) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_TEST1,
# 2235 "./ipret-1.inc"
[((OPCODE_OPTION_ORD_FLAT) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_ORD_FLAT1,
# 2249 "./ipret-1.inc"
[((OPCODE_OPTION_ORD) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_ORD1,
# 2285 "./ipret-1.inc"
[((OPCODE_ARRAY_CREATE) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_CREATE1,
# 2356 "./ipret-1.inc"
[((OPCODE_ARRAY_CREATE_EMPTY_FLAT) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_CREATE_EMPTY_FLAT1,
# 2370 "./ipret-1.inc"
[((OPCODE_ARRAY_CREATE_EMPTY) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_CREATE_EMPTY1,
# 2382 "./ipret-1.inc"
[((OPCODE_ARRAY_FILL) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_FILL1,
# 2442 "./ipret-1.inc"
[((OPCODE_ARRAY_STRING) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_STRING1,
# 2463 "./ipret-1.inc"
[((OPCODE_ARRAY_UNICODE) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_UNICODE1,
# 2484 "./ipret-1.inc"
[((OPCODE_ARRAY_LOAD) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_LOAD1,
# 2590 "./ipret-1.inc"
[((OPCODE_ARRAY_LEN) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_LEN1,
# 2608 "./ipret-1.inc"
[((OPCODE_ARRAY_LEN_GREATER_THAN) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_LEN_GREATER_THAN1,
# 2627 "./ipret-1.inc"
[((OPCODE_ARRAY_SUB) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_SUB1,
# 2647 "./ipret-1.inc"
[((OPCODE_ARRAY_SKIP) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_SKIP1,
# 2666 "./ipret-1.inc"
[((OPCODE_ARRAY_APPEND) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_APPEND1,
# 2685 "./ipret-1.inc"
[((OPCODE_ARRAY_APPEND_ONE_FLAT) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_APPEND_ONE_FLAT1,
# 2704 "./ipret-1.inc"
[((OPCODE_ARRAY_APPEND_ONE) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_APPEND_ONE1,
# 2723 "./ipret-1.inc"
[((OPCODE_ARRAY_FLATTEN) + 1 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_FLATTEN1,
# 56 "./ipret.inc" 2





# 1 "./ipret-1.inc" 1
# 317 "./ipret-1.inc"
 [((0 + 0 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_add_int8_t_2, [((0 + 1 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_subtract_int8_t_2, [((0 + 2 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_multiply_int8_t_2, [((0 + 3 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_divide_int8_t_2, [((0 + 5 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_udivide_int8_t_2, [((0 + 7 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_modulo_int8_t_2, [((0 + 9 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_umodulo_int8_t_2, [((0 + 11 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_power_int8_t_2, [((0 + 12 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_and_int8_t_2, [((0 + 13 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_or_int8_t_2, [((0 + 14 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_xor_int8_t_2, [((0 + 15 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shl_int8_t_2, [((0 + 16 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shr_int8_t_2, [((0 + 17 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ushr_int8_t_2, [((0 + 18 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_rol_int8_t_2, [((0 + 19 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ror_int8_t_2, [((0 + 20 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bts_int8_t_2, [((0 + 21 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btr_int8_t_2, [((0 + 22 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btc_int8_t_2, [((0 + 23 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_equal_int8_t_2, [((0 + 24 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_not_equal_int8_t_2, [((0 + 25 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_int8_t_2, [((0 + 26 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_equal_int8_t_2, [((0 + 27 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_int8_t_2, [((0 + 28 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_equal_int8_t_2, [((0 + 29 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bt_int8_t_2, [((0 + 30 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_not_int8_t_2, [((0 + 31 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_neg_int8_t_2, [((0 + 32 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_inc_int8_t_2, [((0 + 33 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_dec_int8_t_2, [((0 + 34 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bswap_int8_t_2, [((0 + 36 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_brev_int8_t_2, [((0 + 38 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsf_int8_t_2, [((0 + 40 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_int8_t_2, [((0 + 42 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_int8_t_2, [((0 + 44 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_to_int_int8_t_2, [((0 + 45 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_uto_int_int8_t_2, [((0 + 46 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_from_int_int8_t_2, [((0 + 47 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_ufrom_int_int8_t_2, [((0 + 48 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_move_int8_t_2, [((0 + 49 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_copy_int8_t_2, [((0 + 50 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_int8_t_2, [((0 + 0 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_add_int16_t_2, [((0 + 1 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_subtract_int16_t_2, [((0 + 2 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_multiply_int16_t_2, [((0 + 3 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_divide_int16_t_2, [((0 + 5 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_udivide_int16_t_2, [((0 + 7 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_modulo_int16_t_2, [((0 + 9 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_umodulo_int16_t_2, [((0 + 11 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_power_int16_t_2, [((0 + 12 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_and_int16_t_2, [((0 + 13 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_or_int16_t_2, [((0 + 14 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_xor_int16_t_2, [((0 + 15 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shl_int16_t_2, [((0 + 16 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shr_int16_t_2, [((0 + 17 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ushr_int16_t_2, [((0 + 18 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_rol_int16_t_2, [((0 + 19 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ror_int16_t_2, [((0 + 20 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bts_int16_t_2, [((0 + 21 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btr_int16_t_2, [((0 + 22 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btc_int16_t_2, [((0 + 23 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_equal_int16_t_2, [((0 + 24 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_not_equal_int16_t_2, [((0 + 25 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_int16_t_2, [((0 + 26 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_equal_int16_t_2, [((0 + 27 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_int16_t_2, [((0 + 28 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_equal_int16_t_2, [((0 + 29 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bt_int16_t_2, [((0 + 30 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_not_int16_t_2, [((0 + 31 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_neg_int16_t_2, [((0 + 32 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_inc_int16_t_2, [((0 + 33 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_dec_int16_t_2, [((0 + 34 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bswap_int16_t_2, [((0 + 36 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_brev_int16_t_2, [((0 + 38 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsf_int16_t_2, [((0 + 40 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_int16_t_2, [((0 + 42 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_int16_t_2, [((0 + 44 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_to_int_int16_t_2, [((0 + 45 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_uto_int_int16_t_2, [((0 + 46 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_from_int_int16_t_2, [((0 + 47 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_ufrom_int_int16_t_2, [((0 + 48 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_move_int16_t_2, [((0 + 49 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_copy_int16_t_2, [((0 + 50 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_int16_t_2, [((0 + 0 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_add_int32_t_2, [((0 + 1 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_subtract_int32_t_2, [((0 + 2 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_multiply_int32_t_2, [((0 + 3 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_divide_int32_t_2, [((0 + 5 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_udivide_int32_t_2, [((0 + 7 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_modulo_int32_t_2, [((0 + 9 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_umodulo_int32_t_2, [((0 + 11 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_power_int32_t_2, [((0 + 12 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_and_int32_t_2, [((0 + 13 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_or_int32_t_2, [((0 + 14 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_xor_int32_t_2, [((0 + 15 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shl_int32_t_2, [((0 + 16 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shr_int32_t_2, [((0 + 17 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ushr_int32_t_2, [((0 + 18 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_rol_int32_t_2, [((0 + 19 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ror_int32_t_2, [((0 + 20 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bts_int32_t_2, [((0 + 21 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btr_int32_t_2, [((0 + 22 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btc_int32_t_2, [((0 + 23 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_equal_int32_t_2, [((0 + 24 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_not_equal_int32_t_2, [((0 + 25 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_int32_t_2, [((0 + 26 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_equal_int32_t_2, [((0 + 27 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_int32_t_2, [((0 + 28 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_equal_int32_t_2, [((0 + 29 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bt_int32_t_2, [((0 + 30 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_not_int32_t_2, [((0 + 31 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_neg_int32_t_2, [((0 + 32 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_inc_int32_t_2, [((0 + 33 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_dec_int32_t_2, [((0 + 34 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bswap_int32_t_2, [((0 + 36 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_brev_int32_t_2, [((0 + 38 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsf_int32_t_2, [((0 + 40 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_int32_t_2, [((0 + 42 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_int32_t_2, [((0 + 44 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_to_int_int32_t_2, [((0 + 45 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_uto_int_int32_t_2, [((0 + 46 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_from_int_int32_t_2, [((0 + 47 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_ufrom_int_int32_t_2, [((0 + 48 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_move_int32_t_2, [((0 + 49 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_copy_int32_t_2, [((0 + 50 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_int32_t_2, [((0 + 0 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_add_int64_t_2, [((0 + 1 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_subtract_int64_t_2, [((0 + 2 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_multiply_int64_t_2, [((0 + 3 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_divide_int64_t_2, [((0 + 5 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_udivide_int64_t_2, [((0 + 7 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_modulo_int64_t_2, [((0 + 9 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_umodulo_int64_t_2, [((0 + 11 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_power_int64_t_2, [((0 + 12 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_and_int64_t_2, [((0 + 13 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_or_int64_t_2, [((0 + 14 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_xor_int64_t_2, [((0 + 15 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shl_int64_t_2, [((0 + 16 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shr_int64_t_2, [((0 + 17 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ushr_int64_t_2, [((0 + 18 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_rol_int64_t_2, [((0 + 19 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ror_int64_t_2, [((0 + 20 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bts_int64_t_2, [((0 + 21 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btr_int64_t_2, [((0 + 22 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btc_int64_t_2, [((0 + 23 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_equal_int64_t_2, [((0 + 24 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_not_equal_int64_t_2, [((0 + 25 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_int64_t_2, [((0 + 26 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_equal_int64_t_2, [((0 + 27 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_int64_t_2, [((0 + 28 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_equal_int64_t_2, [((0 + 29 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bt_int64_t_2, [((0 + 30 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_not_int64_t_2, [((0 + 31 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_neg_int64_t_2, [((0 + 32 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_inc_int64_t_2, [((0 + 33 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_dec_int64_t_2, [((0 + 34 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bswap_int64_t_2, [((0 + 36 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_brev_int64_t_2, [((0 + 38 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsf_int64_t_2, [((0 + 40 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_int64_t_2, [((0 + 42 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_int64_t_2, [((0 + 44 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_to_int_int64_t_2, [((0 + 45 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_uto_int_int64_t_2, [((0 + 46 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_from_int_int64_t_2, [((0 + 47 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_ufrom_int_int64_t_2, [((0 + 48 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_move_int64_t_2, [((0 + 49 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_copy_int64_t_2, [((0 + 50 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_int64_t_2, [((0 + 0 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_add_int128_t_2, [((0 + 1 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_subtract_int128_t_2, [((0 + 2 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_multiply_int128_t_2, [((0 + 3 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_divide_int128_t_2, [((0 + 5 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_udivide_int128_t_2, [((0 + 7 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_modulo_int128_t_2, [((0 + 9 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_umodulo_int128_t_2, [((0 + 11 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_power_int128_t_2, [((0 + 12 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_and_int128_t_2, [((0 + 13 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_or_int128_t_2, [((0 + 14 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_xor_int128_t_2, [((0 + 15 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shl_int128_t_2, [((0 + 16 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_shr_int128_t_2, [((0 + 17 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ushr_int128_t_2, [((0 + 18 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_rol_int128_t_2, [((0 + 19 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_ror_int128_t_2, [((0 + 20 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bts_int128_t_2, [((0 + 21 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btr_int128_t_2, [((0 + 22 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_btc_int128_t_2, [((0 + 23 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_equal_int128_t_2, [((0 + 24 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_not_equal_int128_t_2, [((0 + 25 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_int128_t_2, [((0 + 26 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_less_equal_int128_t_2, [((0 + 27 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_int128_t_2, [((0 + 28 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_uless_equal_int128_t_2, [((0 + 29 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_binary_bt_int128_t_2, [((0 + 30 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_not_int128_t_2, [((0 + 31 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_neg_int128_t_2, [((0 + 32 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_inc_int128_t_2, [((0 + 33 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_dec_int128_t_2, [((0 + 34 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bswap_int128_t_2, [((0 + 36 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_brev_int128_t_2, [((0 + 38 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsf_int128_t_2, [((0 + 40 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_int128_t_2, [((0 + 42 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_int128_t_2, [((0 + 44 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_to_int_int128_t_2, [((0 + 45 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_uto_int_int128_t_2, [((0 + 46 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_from_int_int128_t_2, [((0 + 47 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_ufrom_int_int128_t_2, [((0 + 48 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_move_int128_t_2, [((0 + 49 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_copy_int128_t_2, [((0 + 50 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_int128_t_2,


[((0 + 51 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_fixed_ldc16_int32_t_2,

[((0 + 51 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_fixed_ldc16_int64_t_2,

[((0 + 51 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_fixed_ldc16_int128_t_2,
# 420 "./ipret-1.inc"
 [((((0 + 52 * 5) + 35 * 5) + 0 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 3 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 6 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 9 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 12 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_modulo_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 13 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_power_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 14 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_ldexp_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 15 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_atan2_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 16 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 19 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 22 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 25 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 28 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 31 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 35 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cbrt_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 36 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sin_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 37 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cos_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 38 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tan_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 39 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asin_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 40 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acos_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 41 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atan_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 42 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sinh_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 43 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cosh_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 44 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tanh_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 45 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asinh_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 46 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acosh_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 47 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atanh_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 48 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp2_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 49 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 50 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp10_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 51 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log2_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 52 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 53 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log10_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 54 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_round_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 56 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_ceil_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 55 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_floor_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 57 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_trunc_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 58 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_fract_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 59 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_mantissa_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 60 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exponent_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 61 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_next_number_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 62 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_prev_number_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 63 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 66 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 69 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 72 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_move_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 73 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_copy_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 74 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_real16_t_2, [((((0 + 52 * 5) + 35 * 5) + 0 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 3 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 6 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 9 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 12 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_modulo_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 13 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_power_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 14 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_ldexp_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 15 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_atan2_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 16 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 19 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 22 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 25 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 28 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 31 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 35 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cbrt_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 36 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sin_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 37 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cos_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 38 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tan_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 39 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asin_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 40 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acos_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 41 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atan_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 42 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sinh_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 43 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cosh_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 44 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tanh_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 45 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asinh_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 46 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acosh_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 47 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atanh_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 48 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp2_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 49 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 50 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp10_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 51 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log2_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 52 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 53 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log10_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 54 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_round_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 56 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_ceil_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 55 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_floor_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 57 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_trunc_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 58 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_fract_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 59 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_mantissa_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 60 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exponent_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 61 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_next_number_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 62 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_prev_number_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 63 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 66 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 69 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 72 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_move_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 73 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_copy_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 74 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_real32_t_2, [((((0 + 52 * 5) + 35 * 5) + 0 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 3 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 6 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 9 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 12 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_modulo_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 13 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_power_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 14 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_ldexp_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 15 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_atan2_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 16 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 19 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 22 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 25 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 28 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 31 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 35 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cbrt_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 36 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sin_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 37 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cos_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 38 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tan_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 39 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asin_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 40 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acos_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 41 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atan_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 42 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sinh_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 43 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cosh_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 44 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tanh_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 45 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asinh_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 46 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acosh_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 47 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atanh_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 48 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp2_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 49 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 50 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp10_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 51 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log2_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 52 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 53 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log10_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 54 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_round_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 56 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_ceil_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 55 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_floor_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 57 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_trunc_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 58 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_fract_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 59 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_mantissa_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 60 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exponent_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 61 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_next_number_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 62 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_prev_number_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 63 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 66 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 69 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 72 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_move_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 73 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_copy_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 74 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_real64_t_2, [((((0 + 52 * 5) + 35 * 5) + 0 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 3 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 6 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 9 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 12 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_modulo_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 13 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_power_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 14 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_ldexp_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 15 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_atan2_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 16 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 19 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 22 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 25 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 28 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 31 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 35 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cbrt_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 36 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sin_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 37 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cos_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 38 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tan_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 39 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asin_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 40 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acos_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 41 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atan_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 42 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sinh_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 43 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_cosh_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 44 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_tanh_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 45 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_asinh_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 46 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_acosh_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 47 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_atanh_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 48 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp2_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 49 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 50 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exp10_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 51 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log2_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 52 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 53 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_log10_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 54 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_round_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 56 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_ceil_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 55 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_floor_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 57 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_trunc_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 58 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_fract_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 59 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_mantissa_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 60 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_exponent_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 61 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_next_number_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 62 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_prev_number_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 63 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 66 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 69 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 72 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_move_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 73 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_copy_real80_t_2, [((((0 + 52 * 5) + 35 * 5) + 74 * 1 + 3 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_fixed_ldc_real80_t_2,
# 655 "./ipret-1.inc"
[(((0 + 52 * 5) + 0 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_add_int8_t_2, [(((0 + 52 * 5) + 1 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_subtract_int8_t_2, [(((0 + 52 * 5) + 2 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_multiply_int8_t_2, [(((0 + 52 * 5) + 3 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_divide_int8_t_2, [(((0 + 52 * 5) + 5 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_modulo_int8_t_2, [(((0 + 52 * 5) + 7 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_power_int8_t_2, [(((0 + 52 * 5) + 8 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_and_int8_t_2, [(((0 + 52 * 5) + 9 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_or_int8_t_2, [(((0 + 52 * 5) + 10 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_xor_int8_t_2, [(((0 + 52 * 5) + 11 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_shl_int8_t_2, [(((0 + 52 * 5) + 12 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_shr_int8_t_2, [(((0 + 52 * 5) + 13 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_bts_int8_t_2, [(((0 + 52 * 5) + 14 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_btr_int8_t_2, [(((0 + 52 * 5) + 15 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_btc_int8_t_2, [(((0 + 52 * 5) + 16 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_equal_int8_t_2, [(((0 + 52 * 5) + 17 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_not_equal_int8_t_2, [(((0 + 52 * 5) + 18 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_less_int8_t_2, [(((0 + 52 * 5) + 19 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_less_equal_int8_t_2, [(((0 + 52 * 5) + 20 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_bt_int8_t_2, [(((0 + 52 * 5) + 21 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_not_int8_t_2, [(((0 + 52 * 5) + 22 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_neg_int8_t_2, [(((0 + 52 * 5) + 23 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_inc_int8_t_2, [(((0 + 52 * 5) + 24 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_dec_int8_t_2, [(((0 + 52 * 5) + 25 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_bsf_int8_t_2, [(((0 + 52 * 5) + 26 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_bsr_int8_t_2, [(((0 + 52 * 5) + 27 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_int8_t_2, [(((0 + 52 * 5) + 29 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_INT_unary_to_int_int8_t_2, [(((0 + 52 * 5) + 30 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_INT_unary_from_int_int8_t_2, [(((0 + 52 * 5) + 31 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_INT_move_int8_t_2, [(((0 + 52 * 5) + 32 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_INT_copy_int8_t_2, [(((0 + 52 * 5) + 33 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_ldc_int8_t_2, [(((0 + 52 * 5) + 34 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_ldc16_int8_t_2, [(((0 + 52 * 5) + 0 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_add_int16_t_2, [(((0 + 52 * 5) + 1 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_subtract_int16_t_2, [(((0 + 52 * 5) + 2 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_multiply_int16_t_2, [(((0 + 52 * 5) + 3 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_divide_int16_t_2, [(((0 + 52 * 5) + 5 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_modulo_int16_t_2, [(((0 + 52 * 5) + 7 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_power_int16_t_2, [(((0 + 52 * 5) + 8 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_and_int16_t_2, [(((0 + 52 * 5) + 9 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_or_int16_t_2, [(((0 + 52 * 5) + 10 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_xor_int16_t_2, [(((0 + 52 * 5) + 11 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_shl_int16_t_2, [(((0 + 52 * 5) + 12 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_shr_int16_t_2, [(((0 + 52 * 5) + 13 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_bts_int16_t_2, [(((0 + 52 * 5) + 14 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_btr_int16_t_2, [(((0 + 52 * 5) + 15 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_btc_int16_t_2, [(((0 + 52 * 5) + 16 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_equal_int16_t_2, [(((0 + 52 * 5) + 17 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_not_equal_int16_t_2, [(((0 + 52 * 5) + 18 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_less_int16_t_2, [(((0 + 52 * 5) + 19 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_less_equal_int16_t_2, [(((0 + 52 * 5) + 20 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_bt_int16_t_2, [(((0 + 52 * 5) + 21 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_not_int16_t_2, [(((0 + 52 * 5) + 22 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_neg_int16_t_2, [(((0 + 52 * 5) + 23 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_inc_int16_t_2, [(((0 + 52 * 5) + 24 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_dec_int16_t_2, [(((0 + 52 * 5) + 25 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_bsf_int16_t_2, [(((0 + 52 * 5) + 26 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_bsr_int16_t_2, [(((0 + 52 * 5) + 27 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_int16_t_2, [(((0 + 52 * 5) + 29 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_INT_unary_to_int_int16_t_2, [(((0 + 52 * 5) + 30 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_INT_unary_from_int_int16_t_2, [(((0 + 52 * 5) + 31 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_INT_move_int16_t_2, [(((0 + 52 * 5) + 32 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_INT_copy_int16_t_2, [(((0 + 52 * 5) + 33 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_ldc_int16_t_2, [(((0 + 52 * 5) + 34 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_ldc16_int16_t_2, [(((0 + 52 * 5) + 0 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_add_int32_t_2, [(((0 + 52 * 5) + 1 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_subtract_int32_t_2, [(((0 + 52 * 5) + 2 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_multiply_int32_t_2, [(((0 + 52 * 5) + 3 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_divide_int32_t_2, [(((0 + 52 * 5) + 5 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_modulo_int32_t_2, [(((0 + 52 * 5) + 7 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_power_int32_t_2, [(((0 + 52 * 5) + 8 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_and_int32_t_2, [(((0 + 52 * 5) + 9 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_or_int32_t_2, [(((0 + 52 * 5) + 10 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_xor_int32_t_2, [(((0 + 52 * 5) + 11 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_shl_int32_t_2, [(((0 + 52 * 5) + 12 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_shr_int32_t_2, [(((0 + 52 * 5) + 13 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_bts_int32_t_2, [(((0 + 52 * 5) + 14 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_btr_int32_t_2, [(((0 + 52 * 5) + 15 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_btc_int32_t_2, [(((0 + 52 * 5) + 16 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_equal_int32_t_2, [(((0 + 52 * 5) + 17 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_not_equal_int32_t_2, [(((0 + 52 * 5) + 18 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_less_int32_t_2, [(((0 + 52 * 5) + 19 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_less_equal_int32_t_2, [(((0 + 52 * 5) + 20 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_bt_int32_t_2, [(((0 + 52 * 5) + 21 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_not_int32_t_2, [(((0 + 52 * 5) + 22 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_neg_int32_t_2, [(((0 + 52 * 5) + 23 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_inc_int32_t_2, [(((0 + 52 * 5) + 24 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_dec_int32_t_2, [(((0 + 52 * 5) + 25 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_bsf_int32_t_2, [(((0 + 52 * 5) + 26 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_bsr_int32_t_2, [(((0 + 52 * 5) + 27 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_int32_t_2, [(((0 + 52 * 5) + 29 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_INT_unary_to_int_int32_t_2, [(((0 + 52 * 5) + 30 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_INT_unary_from_int_int32_t_2, [(((0 + 52 * 5) + 31 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_INT_move_int32_t_2, [(((0 + 52 * 5) + 32 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_INT_copy_int32_t_2, [(((0 + 52 * 5) + 33 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_ldc_int32_t_2, [(((0 + 52 * 5) + 34 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_ldc16_int32_t_2, [(((0 + 52 * 5) + 0 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_add_int64_t_2, [(((0 + 52 * 5) + 1 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_subtract_int64_t_2, [(((0 + 52 * 5) + 2 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_multiply_int64_t_2, [(((0 + 52 * 5) + 3 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_divide_int64_t_2, [(((0 + 52 * 5) + 5 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_modulo_int64_t_2, [(((0 + 52 * 5) + 7 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_power_int64_t_2, [(((0 + 52 * 5) + 8 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_and_int64_t_2, [(((0 + 52 * 5) + 9 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_or_int64_t_2, [(((0 + 52 * 5) + 10 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_xor_int64_t_2, [(((0 + 52 * 5) + 11 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_shl_int64_t_2, [(((0 + 52 * 5) + 12 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_shr_int64_t_2, [(((0 + 52 * 5) + 13 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_bts_int64_t_2, [(((0 + 52 * 5) + 14 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_btr_int64_t_2, [(((0 + 52 * 5) + 15 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_btc_int64_t_2, [(((0 + 52 * 5) + 16 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_equal_int64_t_2, [(((0 + 52 * 5) + 17 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_not_equal_int64_t_2, [(((0 + 52 * 5) + 18 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_less_int64_t_2, [(((0 + 52 * 5) + 19 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_less_equal_int64_t_2, [(((0 + 52 * 5) + 20 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_bt_int64_t_2, [(((0 + 52 * 5) + 21 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_not_int64_t_2, [(((0 + 52 * 5) + 22 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_neg_int64_t_2, [(((0 + 52 * 5) + 23 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_inc_int64_t_2, [(((0 + 52 * 5) + 24 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_dec_int64_t_2, [(((0 + 52 * 5) + 25 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_bsf_int64_t_2, [(((0 + 52 * 5) + 26 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_bsr_int64_t_2, [(((0 + 52 * 5) + 27 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_int64_t_2, [(((0 + 52 * 5) + 29 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_INT_unary_to_int_int64_t_2, [(((0 + 52 * 5) + 30 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_INT_unary_from_int_int64_t_2, [(((0 + 52 * 5) + 31 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_INT_move_int64_t_2, [(((0 + 52 * 5) + 32 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_INT_copy_int64_t_2, [(((0 + 52 * 5) + 33 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_ldc_int64_t_2, [(((0 + 52 * 5) + 34 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_ldc16_int64_t_2, [(((0 + 52 * 5) + 0 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_add_int128_t_2, [(((0 + 52 * 5) + 1 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_subtract_int128_t_2, [(((0 + 52 * 5) + 2 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_multiply_int128_t_2, [(((0 + 52 * 5) + 3 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_divide_int128_t_2, [(((0 + 52 * 5) + 5 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_modulo_int128_t_2, [(((0 + 52 * 5) + 7 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_power_int128_t_2, [(((0 + 52 * 5) + 8 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_and_int128_t_2, [(((0 + 52 * 5) + 9 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_or_int128_t_2, [(((0 + 52 * 5) + 10 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_xor_int128_t_2, [(((0 + 52 * 5) + 11 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_shl_int128_t_2, [(((0 + 52 * 5) + 12 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_shr_int128_t_2, [(((0 + 52 * 5) + 13 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_bts_int128_t_2, [(((0 + 52 * 5) + 14 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_btr_int128_t_2, [(((0 + 52 * 5) + 15 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_btc_int128_t_2, [(((0 + 52 * 5) + 16 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_equal_int128_t_2, [(((0 + 52 * 5) + 17 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_not_equal_int128_t_2, [(((0 + 52 * 5) + 18 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_less_int128_t_2, [(((0 + 52 * 5) + 19 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_less_equal_int128_t_2, [(((0 + 52 * 5) + 20 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_bt_int128_t_2, [(((0 + 52 * 5) + 21 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_not_int128_t_2, [(((0 + 52 * 5) + 22 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_neg_int128_t_2, [(((0 + 52 * 5) + 23 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_inc_int128_t_2, [(((0 + 52 * 5) + 24 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_dec_int128_t_2, [(((0 + 52 * 5) + 25 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_bsf_int128_t_2, [(((0 + 52 * 5) + 26 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_bsr_int128_t_2, [(((0 + 52 * 5) + 27 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_int128_t_2, [(((0 + 52 * 5) + 29 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_INT_unary_to_int_int128_t_2, [(((0 + 52 * 5) + 30 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_INT_unary_from_int_int128_t_2, [(((0 + 52 * 5) + 31 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_INT_move_int128_t_2, [(((0 + 52 * 5) + 32 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_INT_copy_int128_t_2, [(((0 + 52 * 5) + 33 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_ldc_int128_t_2, [(((0 + 52 * 5) + 34 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_ldc16_int128_t_2,
# 688 "./ipret-1.inc"
# 1 "./for-fix.inc" 1
# 24 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 41 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_alt1_int8_t_2,
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 43 * 1 + 0 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_alt1_int8_t_2,
# 74 "./ipret-a1.inc" 2
# 25 "./for-fix.inc" 2
# 36 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 41 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_alt1_int16_t_2,
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 43 * 1 + 1 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_alt1_int16_t_2,
# 74 "./ipret-a1.inc" 2
# 37 "./for-fix.inc" 2
# 48 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 41 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_alt1_int32_t_2,
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 43 * 1 + 2 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_alt1_int32_t_2,
# 74 "./ipret-a1.inc" 2
# 49 "./for-fix.inc" 2
# 60 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 41 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_alt1_int64_t_2,
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 43 * 1 + 3 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_alt1_int64_t_2,
# 74 "./ipret-a1.inc" 2
# 61 "./for-fix.inc" 2
# 72 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 41 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_bsr_alt1_int128_t_2,
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((0 + 43 * 1 + 4 * 52) + 2 * OPCODE_MODE_MULT)] = &&label_FIXED_unary_popcnt_alt1_int128_t_2,
# 74 "./ipret-a1.inc" 2
# 73 "./for-fix.inc" 2
# 689 "./ipret-1.inc" 2


# 1 "./for-int.inc" 1
# 24 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[(((0 + 52 * 5) + 28 * 1 + 0 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_alt1_int8_t_2,
# 38 "./ipret-a2.inc" 2
# 25 "./for-int.inc" 2
# 36 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[(((0 + 52 * 5) + 28 * 1 + 1 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_alt1_int16_t_2,
# 38 "./ipret-a2.inc" 2
# 37 "./for-int.inc" 2
# 48 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[(((0 + 52 * 5) + 28 * 1 + 2 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_alt1_int32_t_2,
# 38 "./ipret-a2.inc" 2
# 49 "./for-int.inc" 2
# 60 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[(((0 + 52 * 5) + 28 * 1 + 3 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_alt1_int64_t_2,
# 38 "./ipret-a2.inc" 2
# 61 "./for-int.inc" 2
# 72 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[(((0 + 52 * 5) + 28 * 1 + 4 * 35) + 2 * OPCODE_MODE_MULT)] = &&label_int_binary_popcnt_alt1_int128_t_2,
# 38 "./ipret-a2.inc" 2
# 73 "./for-int.inc" 2
# 692 "./ipret-1.inc" 2


# 1 "./for-real.inc" 1
# 23 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 1 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_alt1_real16_t_2,
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 4 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_alt1_real16_t_2,
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 7 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_alt1_real16_t_2,
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 10 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_alt1_real16_t_2,
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 17 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_alt1_real16_t_2,
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 20 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_alt1_real16_t_2,
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 23 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_alt1_real16_t_2,
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 26 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_alt1_real16_t_2,
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 118 "./ipret-a3.inc" 2
# 149 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 64 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_alt1_real16_t_2,
# 150 "./ipret-a3.inc" 2
# 163 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 67 * 1 + 0 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_alt1_real16_t_2,
# 164 "./ipret-a3.inc" 2
# 24 "./for-real.inc" 2
# 33 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 1 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_alt1_real32_t_2,
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 2 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_alt2_real32_t_2,
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 4 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_alt1_real32_t_2,
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 5 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_alt2_real32_t_2,
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 7 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_alt1_real32_t_2,
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 8 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_alt2_real32_t_2,
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 10 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_alt1_real32_t_2,
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 11 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_alt2_real32_t_2,
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 17 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_alt1_real32_t_2,
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 18 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_alt2_real32_t_2,
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 20 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_alt1_real32_t_2,
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 21 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_alt2_real32_t_2,
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 23 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_alt1_real32_t_2,
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 24 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_alt2_real32_t_2,
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 26 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_alt1_real32_t_2,
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 27 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_alt2_real32_t_2,
# 118 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 29 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_alt1_real32_t_2,
# 125 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 30 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_alt2_real32_t_2,
# 131 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 32 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_alt1_real32_t_2,
# 137 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 33 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_alt2_real32_t_2,
# 143 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 64 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_alt1_real32_t_2,
# 150 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 65 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_alt2_real32_t_2,
# 157 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 67 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_alt1_real32_t_2,
# 164 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 68 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_alt2_real32_t_2,
# 171 "./ipret-a3.inc" 2







# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 70 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_alt1_real32_t_2,
# 179 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 71 * 1 + 1 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_alt2_real32_t_2,
# 185 "./ipret-a3.inc" 2
# 34 "./for-real.inc" 2
# 43 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 1 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_alt1_real64_t_2,
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 2 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_add_alt2_real64_t_2,
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 4 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_alt1_real64_t_2,
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 5 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_subtract_alt2_real64_t_2,
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 7 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_alt1_real64_t_2,
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 8 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_multiply_alt2_real64_t_2,
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 10 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_alt1_real64_t_2,
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 11 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_divide_alt2_real64_t_2,
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 17 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_alt1_real64_t_2,
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 18 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_equal_alt2_real64_t_2,
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 20 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_alt1_real64_t_2,
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 21 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_not_equal_alt2_real64_t_2,
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 23 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_alt1_real64_t_2,
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 24 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_alt2_real64_t_2,
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 26 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_alt1_real64_t_2,
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 27 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_binary_less_equal_alt2_real64_t_2,
# 118 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 29 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_alt1_real64_t_2,
# 125 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 30 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_neg_alt2_real64_t_2,
# 131 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 32 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_alt1_real64_t_2,
# 137 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 33 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_sqrt_alt2_real64_t_2,
# 143 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 64 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_alt1_real64_t_2,
# 150 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 65 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_to_int_alt2_real64_t_2,
# 157 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 67 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_alt1_real64_t_2,
# 164 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 68 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_from_int_alt2_real64_t_2,
# 171 "./ipret-a3.inc" 2







# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 70 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_alt1_real64_t_2,
# 179 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
[((((0 + 52 * 5) + 35 * 5) + 71 * 1 + 2 * 75) + 2 * OPCODE_MODE_MULT)] = &&label_REAL_unary_is_exception_alt2_real64_t_2,
# 185 "./ipret-a3.inc" 2
# 44 "./for-real.inc" 2
# 53 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 54 "./for-real.inc" 2
# 695 "./ipret-1.inc" 2
# 748 "./ipret-1.inc"
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 0 * 1) + 2 * OPCODE_MODE_MULT)] = &&label_bool_binary_and_2,
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 1 * 1) + 2 * OPCODE_MODE_MULT)] = &&label_bool_binary_or_2,
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 2 * 1) + 2 * OPCODE_MODE_MULT)] = &&label_bool_binary_equal_2,
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 3 * 1) + 2 * OPCODE_MODE_MULT)] = &&label_bool_binary_not_equal_2,
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 4 * 1) + 2 * OPCODE_MODE_MULT)] = &&label_bool_binary_less_2,
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 5 * 1) + 2 * OPCODE_MODE_MULT)] = &&label_bool_binary_less_equal_2,
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 6 * 1) + 2 * OPCODE_MODE_MULT)] = &&label_bool_unary_not_2,
# 777 "./ipret-1.inc"
[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 7) + 2 * OPCODE_MODE_MULT)] = &&label_bool_move_2,





[(((((0 + 52 * 5) + 35 * 5) + 75 * 4) + 8) + 2 * OPCODE_MODE_MULT)] = &&label_bool_copy_2,






[((OPCODE_INT_LDC_LONG) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_INT_LDC_LONG2,
# 802 "./ipret-1.inc"
[((OPCODE_IS_EXCEPTION) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_IS_EXCEPTION2,
# 822 "./ipret-1.inc"
[((OPCODE_EXCEPTION_CLASS) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_EXCEPTION_CLASS2,
# 833 "./ipret-1.inc"
[((OPCODE_EXCEPTION_TYPE) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_EXCEPTION_TYPE2,
# 844 "./ipret-1.inc"
[((OPCODE_EXCEPTION_AUX) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_EXCEPTION_AUX2,
# 855 "./ipret-1.inc"
[((OPCODE_SYSTEM_PROPERTY) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_SYSTEM_PROPERTY2,
# 867 "./ipret-1.inc"
[((OPCODE_FLAT_MOVE) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_FLAT_MOVE2,
# 881 "./ipret-1.inc"
[((OPCODE_FLAT_COPY) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_FLAT_COPY2,
# 895 "./ipret-1.inc"
[((OPCODE_REF_MOVE) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_REF_MOVE2,
# 906 "./ipret-1.inc"
[((OPCODE_REF_MOVE_CLEAR) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_REF_MOVE_CLEAR2,
# 916 "./ipret-1.inc"
[((OPCODE_REF_COPY) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_REF_COPY2,
# 926 "./ipret-1.inc"
[((OPCODE_BOX_MOVE_CLEAR) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_BOX_MOVE_CLEAR2,
# 937 "./ipret-1.inc"
[((OPCODE_BOX_COPY) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_BOX_COPY2,
# 947 "./ipret-1.inc"
[((OPCODE_TAKE_BORROWED) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_TAKE_BORROWED2,
# 959 "./ipret-1.inc"
[((OPCODE_DEREFERENCE) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_DEREFERENCE2,
# 977 "./ipret-1.inc"
[((OPCODE_DEREFERENCE_CLEAR) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_DEREFERENCE_CLEAR2,
# 994 "./ipret-1.inc"
[((OPCODE_EVAL) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_EVAL2,
# 1017 "./ipret-1.inc"
[((OPCODE_CHECKPOINT) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_CHECKPOINT2,
# 1134 "./ipret-1.inc"
[((OPCODE_JMP_FALSE) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_JMP_FALSE2,
# 1201 "./ipret-1.inc"
[((OPCODE_LOAD_FN) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_LOAD_FN2,
# 1243 "./ipret-1.inc"
[((OPCODE_CURRY) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_CURRY2,
# 1274 "./ipret-1.inc"
[((OPCODE_CALL) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL2,
# 1349 "./ipret-1.inc"
[((OPCODE_CALL_STRICT) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_STRICT2,






[((OPCODE_CALL_SPARK) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_SPARK2,






[((OPCODE_CALL_INDIRECT) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_INDIRECT2,
# 1423 "./ipret-1.inc"
[((OPCODE_CALL_INDIRECT_STRICT) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_INDIRECT_STRICT2,






[((OPCODE_CALL_INDIRECT_SPARK) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_INDIRECT_SPARK2,






[((OPCODE_CALL_LAZY) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_LAZY2,
# 1496 "./ipret-1.inc"
[((OPCODE_CALL_INDIRECT_LAZY) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_INDIRECT_LAZY2,
# 1514 "./ipret-1.inc"
[((OPCODE_CALL_CACHE) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_CACHE2,
# 1570 "./ipret-1.inc"
[((OPCODE_CALL_SAVE) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_SAVE2,





[((OPCODE_CALL_INDIRECT_CACHE) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_INDIRECT_CACHE2,
# 1672 "./ipret-1.inc"
[((OPCODE_CALL_INDIRECT_SAVE) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_CALL_INDIRECT_SAVE2,







[((OPCODE_RETURN) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_RETURN2,
# 1740 "./ipret-1.inc"
[((OPCODE_STRUCTURED) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_STRUCTURED2,
# 1952 "./ipret-1.inc"
[((OPCODE_RECORD_CREATE) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_RECORD_CREATE2,
# 2031 "./ipret-1.inc"
[((OPCODE_RECORD_LOAD) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_RECORD_LOAD2,
# 2085 "./ipret-1.inc"
[((OPCODE_OPTION_CREATE_EMPTY_FLAT) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_CREATE_EMPTY_FLAT2,
# 2097 "./ipret-1.inc"
[((OPCODE_OPTION_CREATE_EMPTY) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_CREATE_EMPTY2,
# 2115 "./ipret-1.inc"
[((OPCODE_OPTION_CREATE) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_CREATE2,
# 2142 "./ipret-1.inc"
[((OPCODE_OPTION_LOAD) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_LOAD2,
# 2188 "./ipret-1.inc"
[((OPCODE_OPTION_TEST_FLAT) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_TEST_FLAT2,
# 2202 "./ipret-1.inc"
[((OPCODE_OPTION_TEST) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_TEST2,
# 2235 "./ipret-1.inc"
[((OPCODE_OPTION_ORD_FLAT) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_ORD_FLAT2,
# 2249 "./ipret-1.inc"
[((OPCODE_OPTION_ORD) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_OPTION_ORD2,
# 2285 "./ipret-1.inc"
[((OPCODE_ARRAY_CREATE) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_CREATE2,
# 2356 "./ipret-1.inc"
[((OPCODE_ARRAY_CREATE_EMPTY_FLAT) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_CREATE_EMPTY_FLAT2,
# 2370 "./ipret-1.inc"
[((OPCODE_ARRAY_CREATE_EMPTY) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_CREATE_EMPTY2,
# 2382 "./ipret-1.inc"
[((OPCODE_ARRAY_FILL) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_FILL2,
# 2442 "./ipret-1.inc"
[((OPCODE_ARRAY_STRING) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_STRING2,
# 2463 "./ipret-1.inc"
[((OPCODE_ARRAY_UNICODE) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_UNICODE2,
# 2484 "./ipret-1.inc"
[((OPCODE_ARRAY_LOAD) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_LOAD2,
# 2590 "./ipret-1.inc"
[((OPCODE_ARRAY_LEN) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_LEN2,
# 2608 "./ipret-1.inc"
[((OPCODE_ARRAY_LEN_GREATER_THAN) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_LEN_GREATER_THAN2,
# 2627 "./ipret-1.inc"
[((OPCODE_ARRAY_SUB) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_SUB2,
# 2647 "./ipret-1.inc"
[((OPCODE_ARRAY_SKIP) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_SKIP2,
# 2666 "./ipret-1.inc"
[((OPCODE_ARRAY_APPEND) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_APPEND2,
# 2685 "./ipret-1.inc"
[((OPCODE_ARRAY_APPEND_ONE_FLAT) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_APPEND_ONE_FLAT2,
# 2704 "./ipret-1.inc"
[((OPCODE_ARRAY_APPEND_ONE) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_APPEND_ONE2,
# 2723 "./ipret-1.inc"
[((OPCODE_ARRAY_FLATTEN) + 2 * OPCODE_MODE_MULT)] = &&label_OPCODE_ARRAY_FLATTEN2,
# 62 "./ipret.inc" 2
# 631 "ipret.c" 2



 };







 fp = fp_;
 ip = &((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code[ip_];
 (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0));
# 675 "ipret.c"
 next_code:

 code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 693 "ipret.c"
# 1 "./ipret.inc" 1
# 48 "./ipret.inc"
# 1 "./ipret-1.inc" 1
# 317 "./ipret-1.inc"
 label_FIXED_binary_add_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_add_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_subtract_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_subtract_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_multiply_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_multiply_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_divide_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_divide_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_udivide_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_udivide_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_modulo_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_modulo_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_umodulo_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_umodulo_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_power_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_power_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_and_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_and_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_or_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_or_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_xor_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_xor_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shl_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shl_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shr_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shr_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ushr_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ushr_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_rol_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_rol_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ror_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ror_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_bts_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bts_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btr_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btr_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btc_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btc_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_equal_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_equal_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_not_equal_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_not_equal_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_less_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_less_equal_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_equal_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_uless_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_uless_equal_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_equal_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_bt_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bt_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_not_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_not_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_neg_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_neg_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_inc_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_inc_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_dec_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_dec_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bswap_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bswap_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_brev_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_brev_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsf_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsf_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsr_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_popcnt_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_to_int_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int8_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_uto_int_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { uint8_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((uint8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)((uint8_t)r != val1), 0)) || (__builtin_expect((int)(r < 0), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 1)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_from_int_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int64_t val1; int8_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int8_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_ufrom_int_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int64_t val1; uint8_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (uint8_t)val1; if ((__builtin_expect((int)((int64_t)r != val1), 0)) || (__builtin_expect((int)(val1 < 0), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_move_int8_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_copy_int8_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_int8_t_0: do { frame_t slot; uint8_t *val; ip_t sz; slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); ((void)(zero_())); val = (((uint8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int8_t(val, ip + 1 + (((1) + 1) / 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (((1) + 1) / 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_add_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_add_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_subtract_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_subtract_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_multiply_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_multiply_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_divide_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_divide_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_udivide_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_udivide_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_modulo_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_modulo_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_umodulo_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_umodulo_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_power_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_power_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_and_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_and_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_or_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_or_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_xor_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_xor_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shl_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shl_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shr_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shr_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ushr_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ushr_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_rol_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_rol_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ror_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ror_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_bts_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bts_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btr_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btr_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btc_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btc_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_equal_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_equal_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_not_equal_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_not_equal_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_less_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_less_equal_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_equal_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_uless_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_uless_equal_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_equal_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_bt_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bt_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_not_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_not_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_neg_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_neg_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_inc_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_inc_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_dec_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_dec_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bswap_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bswap_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_brev_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_brev_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsf_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsf_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsr_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_popcnt_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_to_int_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int16_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_uto_int_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { uint16_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((uint16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)((uint16_t)r != val1), 0)) || (__builtin_expect((int)(r < 0), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 1)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_from_int_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int64_t val1; int16_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int16_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_ufrom_int_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int64_t val1; uint16_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (uint16_t)val1; if ((__builtin_expect((int)((int64_t)r != val1), 0)) || (__builtin_expect((int)(val1 < 0), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_move_int16_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_copy_int16_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_int16_t_0: do { frame_t slot; uint16_t *val; ip_t sz; slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); ((void)(zero_())); val = (((uint16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int16_t(val, ip + 1 + (((1) + 1) / 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (((1) + 1) / 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_add_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_add_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_subtract_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_subtract_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_multiply_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_multiply_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_divide_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_divide_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_udivide_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_udivide_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_modulo_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_modulo_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_umodulo_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_umodulo_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_power_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_power_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_and_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_and_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_or_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_or_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_xor_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_xor_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shl_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shl_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shr_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shr_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ushr_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ushr_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_rol_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_rol_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ror_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ror_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_bts_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bts_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btr_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btr_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btc_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btc_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_equal_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_equal_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_not_equal_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_not_equal_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_less_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_less_equal_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_equal_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_uless_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_uless_equal_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_equal_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_bt_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bt_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_not_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_not_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_neg_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_neg_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_inc_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_inc_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_dec_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_dec_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bswap_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bswap_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_brev_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_brev_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsf_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsf_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsr_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_popcnt_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_to_int_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int32_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_uto_int_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { uint32_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((uint32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)((uint32_t)r != val1), 0)) || (__builtin_expect((int)(r < 0), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 1)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_from_int_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int64_t val1; int32_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int32_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_ufrom_int_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int64_t val1; uint32_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (uint32_t)val1; if ((__builtin_expect((int)((int64_t)r != val1), 0)) || (__builtin_expect((int)(val1 < 0), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_move_int32_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_copy_int32_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_int32_t_0: do { frame_t slot; uint32_t *val; ip_t sz; slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); ((void)(zero_())); val = (((uint32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int32_t(val, ip + 1 + (((1) + 1) / 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (((1) + 1) / 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_add_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_add_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_subtract_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_subtract_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_multiply_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_multiply_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_divide_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_divide_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_udivide_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_udivide_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_modulo_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_modulo_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_umodulo_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_umodulo_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_power_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_power_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_and_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_and_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_or_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_or_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_xor_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_xor_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shl_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shl_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shr_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shr_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ushr_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ushr_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_rol_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_rol_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ror_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ror_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_bts_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bts_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btr_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btr_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btc_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btc_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_equal_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_equal_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_not_equal_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_not_equal_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_less_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_less_equal_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_equal_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_uless_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_uless_equal_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_equal_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_bt_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bt_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_not_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_not_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_neg_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_neg_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_inc_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_inc_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_dec_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_dec_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bswap_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bswap_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_brev_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_brev_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsf_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsf_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsr_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_popcnt_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_to_int_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int64_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_uto_int_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { uint64_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((uint64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)((uint64_t)r != val1), 0)) || (__builtin_expect((int)(r < 0), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 1)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_from_int_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int64_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_ufrom_int_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int64_t val1; uint64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (uint64_t)val1; if ((__builtin_expect((int)((int64_t)r != val1), 0)) || (__builtin_expect((int)(val1 < 0), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_move_int64_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_copy_int64_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_int64_t_0: do { frame_t slot; uint64_t *val; ip_t sz; slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); ((void)(zero_())); val = (((uint64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int64_t(val, ip + 1 + (((1) + 1) / 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (((1) + 1) / 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_add_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_add_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_subtract_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_subtract_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_multiply_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_multiply_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_divide_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_divide_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_udivide_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_udivide_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_modulo_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_modulo_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_umodulo_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_umodulo_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_power_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_power_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_and_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_and_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_or_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_or_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_xor_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_xor_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shl_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shl_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shr_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shr_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ushr_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ushr_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_rol_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_rol_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ror_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ror_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_bts_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bts_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btr_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btr_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btc_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btc_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_equal_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_equal_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_not_equal_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_not_equal_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_less_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_less_equal_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_equal_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_uless_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_uless_equal_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_equal_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_bt_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bt_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_not_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_not_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_neg_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_neg_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_inc_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_inc_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_dec_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_dec_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bswap_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bswap_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_brev_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_brev_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsf_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsf_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsr_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_popcnt_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_to_int_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int128_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_uto_int_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { uint128_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((uint128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)((uint128_t)r != val1), 0)) || (__builtin_expect((int)(r < 0), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 1)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_from_int_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int64_t val1; int128_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int128_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_ufrom_int_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int64_t val1; uint128_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (uint128_t)val1; if ((__builtin_expect((int)((int64_t)r != val1), 0)) || (__builtin_expect((int)(val1 < 0), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_move_int128_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_copy_int128_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_int128_t_0: do { frame_t slot; uint128_t *val; ip_t sz; slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); ((void)(zero_())); val = (((uint128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int128_t(val, ip + 1 + (((1) + 1) / 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (((1) + 1) / 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


label_fixed_ldc16_int32_t_0: do { frame_t slot; uint32_t *val; ip_t sz; slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); ((void)(zero_())); val = (((uint32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int32_t(val, ip + 1 + (((1) + 1) / 2), 1); __asm__ volatile ("":::"memory"); (ip += (1 + (((1) + 1) / 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_fixed_ldc16_int64_t_0: do { frame_t slot; uint64_t *val; ip_t sz; slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); ((void)(zero_())); val = (((uint64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int64_t(val, ip + 1 + (((1) + 1) / 2), 1); __asm__ volatile ("":::"memory"); (ip += (1 + (((1) + 1) / 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_fixed_ldc16_int128_t_0: do { frame_t slot; uint128_t *val; ip_t sz; slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); ((void)(zero_())); val = (((uint128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int128_t(val, ip + 1 + (((1) + 1) / 2), 1); __asm__ volatile ("":::"memory"); (ip += (1 + (((1) + 1) / 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 420 "./ipret-1.inc"
 label_REAL_binary_add_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_subtract_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_multiply_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_divide_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_modulo_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_modulo_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_power_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_power_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_ldexp_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_ldexp_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_atan2_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_atan2_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_equal_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_not_equal_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_equal_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_neg_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sqrt_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cbrt_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cbrt_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sin_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sin_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cos_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cos_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tan_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tan_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asin_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asin_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acos_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acos_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atan_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atan_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sinh_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sinh_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cosh_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cosh_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tanh_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tanh_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asinh_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asinh_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acosh_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acosh_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atanh_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atanh_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp2_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp2_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp10_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp10_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log2_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log2_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log10_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log10_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_round_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_round_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_ceil_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_ceil_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_floor_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_floor_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_trunc_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_trunc_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_fract_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_fract_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_mantissa_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_mantissa_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exponent_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exponent_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_next_number_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_next_number_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_prev_number_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_prev_number_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_to_int_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_real16_t((((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_from_int_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_real16_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_is_exception_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_move_real16_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_copy_real16_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_real16_t_0: do { frame_t slot; real16_t *val; ip_t sz; slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); ((void)(zero_())); val = (((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_real16_t(val, ip + 1 + (((1) + 1) / 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (((1) + 1) / 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_add_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_subtract_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_multiply_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_divide_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_modulo_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_modulo_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_power_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_power_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_ldexp_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_ldexp_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_atan2_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_atan2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_equal_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_not_equal_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_equal_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_neg_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sqrt_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cbrt_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cbrt_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sin_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sin_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cos_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cos_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tan_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tan_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asin_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asin_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acos_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acos_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atan_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atan_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sinh_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sinh_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cosh_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cosh_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tanh_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tanh_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asinh_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asinh_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acosh_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acosh_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atanh_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atanh_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp2_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp2_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp10_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp10_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log2_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log2_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log10_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log10_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_round_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_round_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_ceil_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_ceil_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_floor_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_floor_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_trunc_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_trunc_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_fract_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_fract_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_mantissa_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_mantissa_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exponent_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exponent_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_next_number_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_next_number_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_prev_number_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_prev_number_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_to_int_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_real32_t((((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_from_int_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_real32_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_is_exception_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_move_real32_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_copy_real32_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_real32_t_0: do { frame_t slot; real32_t *val; ip_t sz; slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); ((void)(zero_())); val = (((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_real32_t(val, ip + 1 + (((1) + 1) / 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (((1) + 1) / 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_add_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_subtract_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_multiply_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_divide_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_modulo_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_modulo_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_power_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_power_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_ldexp_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_ldexp_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_atan2_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_atan2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_equal_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_not_equal_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_equal_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_neg_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sqrt_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cbrt_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cbrt_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sin_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sin_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cos_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cos_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tan_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tan_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asin_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asin_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acos_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acos_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atan_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atan_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sinh_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sinh_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cosh_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cosh_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tanh_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tanh_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asinh_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asinh_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acosh_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acosh_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atanh_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atanh_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp2_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp2_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp10_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp10_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log2_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log2_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log10_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log10_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_round_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_round_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_ceil_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_ceil_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_floor_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_floor_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_trunc_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_trunc_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_fract_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_fract_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_mantissa_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_mantissa_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exponent_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exponent_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_next_number_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_next_number_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_prev_number_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_prev_number_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_to_int_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_real64_t((((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_from_int_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_real64_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_is_exception_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_move_real64_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_copy_real64_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_real64_t_0: do { frame_t slot; real64_t *val; ip_t sz; slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); ((void)(zero_())); val = (((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_real64_t(val, ip + 1 + (((1) + 1) / 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (((1) + 1) / 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_add_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_subtract_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_multiply_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_divide_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_modulo_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_modulo_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_power_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_power_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_ldexp_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_ldexp_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_atan2_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_atan2_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_equal_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_not_equal_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_equal_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_neg_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sqrt_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cbrt_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cbrt_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sin_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sin_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cos_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cos_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tan_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tan_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asin_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asin_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acos_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acos_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atan_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atan_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sinh_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sinh_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cosh_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cosh_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tanh_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tanh_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asinh_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asinh_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acosh_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acosh_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atanh_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atanh_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp2_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp2_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp10_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp10_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log2_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log2_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log10_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log10_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_round_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_round_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_ceil_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_ceil_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_floor_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_floor_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_trunc_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_trunc_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_fract_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_fract_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_mantissa_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_mantissa_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exponent_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exponent_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_next_number_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_next_number_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_prev_number_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_prev_number_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_to_int_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_real80_t((((real80_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_from_int_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_real80_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real80_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_is_exception_real80_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_move_real80_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((real80_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real80_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_copy_real80_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((real80_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real80_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_real80_t_0: do { frame_t slot; real80_t *val; ip_t sz; slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); ((void)(zero_())); val = (((real80_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_real80_t(val, ip + 1 + (((1) + 1) / 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (((1) + 1) / 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


escape_fixed_binary_thunk_0: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_fixed_operator(fp, ip, (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])), (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])), (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])), (!((3) & 1) ? (((const unsigned char *)((ip + 1) + (3) / 2))[0]) : (((const unsigned char *)((ip + 1) + (3) / 2))[1]))); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + (((4) + 1) / 2))); else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 434 "./ipret-1.inc"
escape_fixed_unary_thunk_0: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_fixed_operator(fp, ip, (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])), ((frame_t)-1), (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])), (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]))); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + (((3) + 1) / 2))); else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 445 "./ipret-1.inc"
escape_convert_thunk_0: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_convert(fp, ip, (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])), (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])), (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]))); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + (((3) + 1) / 2))); else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 456 "./ipret-1.inc"
{ _Bool ( *function_int_binary)(const mpint_t *s1, const mpint_t *s2, mpint_t *r, ajla_error_t *err); _Bool ( *function_int_binary_logical)(const mpint_t *s1, const mpint_t *s2, ajla_flat_option_t *r, ajla_error_t *err); _Bool ( *function_int_unary)(const mpint_t *s1, mpint_t *r, ajla_error_t *err);
# 655 "./ipret-1.inc"
label_int_binary_add_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_add_int8_t_0: function_int_binary = mpint_add; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_add_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_add_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_subtract_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_subtract_int8_t_0: function_int_binary = mpint_subtract; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_subtract_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_subtract_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_multiply_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_multiply_int8_t_0: function_int_binary = mpint_multiply; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_multiply_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_multiply_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_divide_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_divide_int8_t_0: function_int_binary = mpint_divide; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_divide_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_divide_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_modulo_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_modulo_int8_t_0: function_int_binary = mpint_modulo; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_modulo_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_modulo_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_power_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_power_int8_t_0: function_int_binary = mpint_power; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_power_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_power_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_and_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_and_int8_t_0: function_int_binary = mpint_and; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_and_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_and_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_or_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_or_int8_t_0: function_int_binary = mpint_or; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_or_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_or_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_xor_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_xor_int8_t_0: function_int_binary = mpint_xor; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_xor_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_xor_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shl_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shl_int8_t_0: function_int_binary = mpint_shl; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shl_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shl_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shr_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shr_int8_t_0: function_int_binary = mpint_shr; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shr_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shr_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bts_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_bts_int8_t_0: function_int_binary = mpint_bts; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bts_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_bts_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btr_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btr_int8_t_0: function_int_binary = mpint_btr; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btr_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btr_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btc_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btc_int8_t_0: function_int_binary = mpint_btc; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btc_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btc_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_equal_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_equal_int8_t_0: function_int_binary_logical = mpint_equal; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_equal_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_equal_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_equal_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_not_equal_int8_t_0: function_int_binary_logical = mpint_not_equal; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_not_equal_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_not_equal_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_int8_t_0: function_int_binary_logical = mpint_less; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_equal_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_equal_int8_t_0: function_int_binary_logical = mpint_less_equal; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_equal_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_equal_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bt_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_bt_int8_t_0: function_int_binary_logical = mpint_bt; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bt_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_bt_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_not_int8_t_0: function_int_unary = mpint_not; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_not_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_not_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_neg_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_neg_int8_t_0: function_int_unary = mpint_neg; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_neg_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_neg_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_inc_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_inc_int8_t_0: function_int_unary = mpint_inc; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_inc_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_inc_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_dec_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_dec_int8_t_0: function_int_unary = mpint_dec; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_dec_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_dec_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsf_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsf_int8_t_0: function_int_unary = mpint_bsf; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsf_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsf_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsr_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsr_int8_t_0: function_int_unary = mpint_bsr; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsr_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsr_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_popcnt_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_int8_t_0: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_to_int_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int8_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_from_int_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int64_t val1; int8_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int8_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_move_int8_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_copy_int8_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc_int8_t_0: do { frame_t slot; int8_t *val; ip_t sz; slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); ((void)(zero_())); val = (((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int8_t(val, ip + 1 + (((1) + 1) / 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (((1) + 1) / 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc16_int8_t_0: do { frame_t slot; int8_t *val; ip_t sz; slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); ((void)(zero_())); val = (((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int8_t(val, ip + 1 + (((1) + 1) / 2), 1); __asm__ volatile ("":::"memory"); (ip += (1 + (((1) + 1) / 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_add_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_add_int16_t_0: function_int_binary = mpint_add; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_add_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_add_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_subtract_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_subtract_int16_t_0: function_int_binary = mpint_subtract; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_subtract_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_subtract_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_multiply_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_multiply_int16_t_0: function_int_binary = mpint_multiply; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_multiply_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_multiply_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_divide_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_divide_int16_t_0: function_int_binary = mpint_divide; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_divide_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_divide_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_modulo_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_modulo_int16_t_0: function_int_binary = mpint_modulo; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_modulo_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_modulo_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_power_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_power_int16_t_0: function_int_binary = mpint_power; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_power_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_power_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_and_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_and_int16_t_0: function_int_binary = mpint_and; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_and_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_and_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_or_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_or_int16_t_0: function_int_binary = mpint_or; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_or_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_or_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_xor_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_xor_int16_t_0: function_int_binary = mpint_xor; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_xor_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_xor_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shl_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shl_int16_t_0: function_int_binary = mpint_shl; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shl_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shl_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shr_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shr_int16_t_0: function_int_binary = mpint_shr; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shr_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shr_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bts_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_bts_int16_t_0: function_int_binary = mpint_bts; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bts_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_bts_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btr_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btr_int16_t_0: function_int_binary = mpint_btr; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btr_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btr_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btc_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btc_int16_t_0: function_int_binary = mpint_btc; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btc_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btc_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_equal_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_equal_int16_t_0: function_int_binary_logical = mpint_equal; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_equal_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_equal_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_equal_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_not_equal_int16_t_0: function_int_binary_logical = mpint_not_equal; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_not_equal_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_not_equal_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_int16_t_0: function_int_binary_logical = mpint_less; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_equal_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_equal_int16_t_0: function_int_binary_logical = mpint_less_equal; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_equal_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_equal_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bt_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_bt_int16_t_0: function_int_binary_logical = mpint_bt; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bt_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_bt_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_not_int16_t_0: function_int_unary = mpint_not; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_not_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_not_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_neg_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_neg_int16_t_0: function_int_unary = mpint_neg; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_neg_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_neg_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_inc_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_inc_int16_t_0: function_int_unary = mpint_inc; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_inc_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_inc_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_dec_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_dec_int16_t_0: function_int_unary = mpint_dec; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_dec_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_dec_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsf_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsf_int16_t_0: function_int_unary = mpint_bsf; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsf_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsf_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsr_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsr_int16_t_0: function_int_unary = mpint_bsr; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsr_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsr_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_popcnt_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_int16_t_0: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_to_int_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int16_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_from_int_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int64_t val1; int16_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int16_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_move_int16_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_copy_int16_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc_int16_t_0: do { frame_t slot; int16_t *val; ip_t sz; slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); ((void)(zero_())); val = (((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int16_t(val, ip + 1 + (((1) + 1) / 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (((1) + 1) / 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc16_int16_t_0: do { frame_t slot; int16_t *val; ip_t sz; slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); ((void)(zero_())); val = (((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int16_t(val, ip + 1 + (((1) + 1) / 2), 1); __asm__ volatile ("":::"memory"); (ip += (1 + (((1) + 1) / 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_add_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_add_int32_t_0: function_int_binary = mpint_add; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_add_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_add_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_subtract_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_subtract_int32_t_0: function_int_binary = mpint_subtract; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_subtract_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_subtract_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_multiply_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_multiply_int32_t_0: function_int_binary = mpint_multiply; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_multiply_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_multiply_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_divide_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_divide_int32_t_0: function_int_binary = mpint_divide; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_divide_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_divide_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_modulo_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_modulo_int32_t_0: function_int_binary = mpint_modulo; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_modulo_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_modulo_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_power_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_power_int32_t_0: function_int_binary = mpint_power; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_power_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_power_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_and_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_and_int32_t_0: function_int_binary = mpint_and; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_and_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_and_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_or_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_or_int32_t_0: function_int_binary = mpint_or; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_or_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_or_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_xor_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_xor_int32_t_0: function_int_binary = mpint_xor; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_xor_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_xor_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shl_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shl_int32_t_0: function_int_binary = mpint_shl; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shl_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shl_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shr_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shr_int32_t_0: function_int_binary = mpint_shr; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shr_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shr_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bts_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_bts_int32_t_0: function_int_binary = mpint_bts; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bts_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_bts_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btr_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btr_int32_t_0: function_int_binary = mpint_btr; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btr_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btr_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btc_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btc_int32_t_0: function_int_binary = mpint_btc; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btc_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btc_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_equal_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_equal_int32_t_0: function_int_binary_logical = mpint_equal; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_equal_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_equal_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_equal_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_not_equal_int32_t_0: function_int_binary_logical = mpint_not_equal; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_not_equal_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_not_equal_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_int32_t_0: function_int_binary_logical = mpint_less; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_equal_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_equal_int32_t_0: function_int_binary_logical = mpint_less_equal; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_equal_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_equal_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bt_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_bt_int32_t_0: function_int_binary_logical = mpint_bt; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bt_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_bt_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_not_int32_t_0: function_int_unary = mpint_not; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_not_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_not_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_neg_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_neg_int32_t_0: function_int_unary = mpint_neg; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_neg_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_neg_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_inc_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_inc_int32_t_0: function_int_unary = mpint_inc; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_inc_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_inc_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_dec_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_dec_int32_t_0: function_int_unary = mpint_dec; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_dec_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_dec_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsf_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsf_int32_t_0: function_int_unary = mpint_bsf; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsf_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsf_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsr_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsr_int32_t_0: function_int_unary = mpint_bsr; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsr_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsr_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_popcnt_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_int32_t_0: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_to_int_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int32_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_from_int_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int64_t val1; int32_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int32_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_move_int32_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_copy_int32_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc_int32_t_0: do { frame_t slot; int32_t *val; ip_t sz; slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); ((void)(zero_())); val = (((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int32_t(val, ip + 1 + (((1) + 1) / 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (((1) + 1) / 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc16_int32_t_0: do { frame_t slot; int32_t *val; ip_t sz; slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); ((void)(zero_())); val = (((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int32_t(val, ip + 1 + (((1) + 1) / 2), 1); __asm__ volatile ("":::"memory"); (ip += (1 + (((1) + 1) / 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_add_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_add_int64_t_0: function_int_binary = mpint_add; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_add_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_add_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_subtract_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_subtract_int64_t_0: function_int_binary = mpint_subtract; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_subtract_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_subtract_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_multiply_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_multiply_int64_t_0: function_int_binary = mpint_multiply; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_multiply_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_multiply_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_divide_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_divide_int64_t_0: function_int_binary = mpint_divide; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_divide_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_divide_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_modulo_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_modulo_int64_t_0: function_int_binary = mpint_modulo; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_modulo_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_modulo_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_power_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_power_int64_t_0: function_int_binary = mpint_power; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_power_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_power_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_and_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_and_int64_t_0: function_int_binary = mpint_and; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_and_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_and_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_or_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_or_int64_t_0: function_int_binary = mpint_or; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_or_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_or_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_xor_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_xor_int64_t_0: function_int_binary = mpint_xor; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_xor_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_xor_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shl_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shl_int64_t_0: function_int_binary = mpint_shl; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shl_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shl_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shr_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shr_int64_t_0: function_int_binary = mpint_shr; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shr_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shr_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bts_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_bts_int64_t_0: function_int_binary = mpint_bts; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bts_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_bts_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btr_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btr_int64_t_0: function_int_binary = mpint_btr; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btr_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btr_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btc_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btc_int64_t_0: function_int_binary = mpint_btc; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btc_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btc_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_equal_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_equal_int64_t_0: function_int_binary_logical = mpint_equal; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_equal_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_equal_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_equal_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_not_equal_int64_t_0: function_int_binary_logical = mpint_not_equal; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_not_equal_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_not_equal_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_int64_t_0: function_int_binary_logical = mpint_less; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_equal_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_equal_int64_t_0: function_int_binary_logical = mpint_less_equal; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_equal_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_equal_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bt_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_bt_int64_t_0: function_int_binary_logical = mpint_bt; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bt_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_bt_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_not_int64_t_0: function_int_unary = mpint_not; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_not_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_not_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_neg_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_neg_int64_t_0: function_int_unary = mpint_neg; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_neg_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_neg_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_inc_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_inc_int64_t_0: function_int_unary = mpint_inc; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_inc_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_inc_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_dec_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_dec_int64_t_0: function_int_unary = mpint_dec; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_dec_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_dec_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsf_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsf_int64_t_0: function_int_unary = mpint_bsf; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsf_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsf_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsr_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsr_int64_t_0: function_int_unary = mpint_bsr; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsr_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsr_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_popcnt_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_int64_t_0: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_to_int_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int64_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_from_int_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int64_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_move_int64_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_copy_int64_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc_int64_t_0: do { frame_t slot; int64_t *val; ip_t sz; slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); ((void)(zero_())); val = (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int64_t(val, ip + 1 + (((1) + 1) / 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (((1) + 1) / 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc16_int64_t_0: do { frame_t slot; int64_t *val; ip_t sz; slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); ((void)(zero_())); val = (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int64_t(val, ip + 1 + (((1) + 1) / 2), 1); __asm__ volatile ("":::"memory"); (ip += (1 + (((1) + 1) / 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_add_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_add_int128_t_0: function_int_binary = mpint_add; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_add_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_add_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_subtract_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_subtract_int128_t_0: function_int_binary = mpint_subtract; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_subtract_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_subtract_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_multiply_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_multiply_int128_t_0: function_int_binary = mpint_multiply; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_multiply_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_multiply_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_divide_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_divide_int128_t_0: function_int_binary = mpint_divide; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_divide_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_divide_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_modulo_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_modulo_int128_t_0: function_int_binary = mpint_modulo; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_modulo_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_modulo_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_power_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_power_int128_t_0: function_int_binary = mpint_power; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_power_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_power_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_and_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_and_int128_t_0: function_int_binary = mpint_and; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_and_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_and_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_or_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_or_int128_t_0: function_int_binary = mpint_or; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_or_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_or_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_xor_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_xor_int128_t_0: function_int_binary = mpint_xor; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_xor_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_xor_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shl_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shl_int128_t_0: function_int_binary = mpint_shl; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shl_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shl_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shr_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shr_int128_t_0: function_int_binary = mpint_shr; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shr_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shr_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bts_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_bts_int128_t_0: function_int_binary = mpint_bts; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bts_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_bts_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btr_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btr_int128_t_0: function_int_binary = mpint_btr; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btr_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btr_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btc_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btc_int128_t_0: function_int_binary = mpint_btc; goto escape_int_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btc_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btc_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_equal_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_equal_int128_t_0: function_int_binary_logical = mpint_equal; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_equal_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_equal_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_equal_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_not_equal_int128_t_0: function_int_binary_logical = mpint_not_equal; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_not_equal_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_not_equal_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_int128_t_0: function_int_binary_logical = mpint_less; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_equal_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_equal_int128_t_0: function_int_binary_logical = mpint_less_equal; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_equal_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_equal_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bt_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_bt_int128_t_0: function_int_binary_logical = mpint_bt; goto escape_int_binary_logical_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bt_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_bt_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_not_int128_t_0: function_int_unary = mpint_not; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_not_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_not_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_neg_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_neg_int128_t_0: function_int_unary = mpint_neg; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_neg_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_neg_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_inc_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_inc_int128_t_0: function_int_unary = mpint_inc; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_inc_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_inc_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_dec_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_dec_int128_t_0: function_int_unary = mpint_dec; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_dec_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_dec_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsf_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsf_int128_t_0: function_int_unary = mpint_bsf; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsf_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsf_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsr_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsr_int128_t_0: function_int_unary = mpint_bsr; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsr_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsr_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_popcnt_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_int128_t_0: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_to_int_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int128_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_from_int_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { int64_t val1; int128_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int128_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_move_int128_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_copy_int128_t_0: do { do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc_int128_t_0: do { frame_t slot; int128_t *val; ip_t sz; slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); ((void)(zero_())); val = (((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int128_t(val, ip + 1 + (((1) + 1) / 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (((1) + 1) / 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc16_int128_t_0: do { frame_t slot; int128_t *val; ip_t sz; slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); ((void)(zero_())); val = (((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int128_t(val, ip + 1 + (((1) + 1) / 2), 1); __asm__ volatile ("":::"memory"); (ip += (1 + (((1) + 1) / 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

escape_int_binary_thunk_0: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_int_binary_operator(fp, ip, (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])), (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])), (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])), (!((3) & 1) ? (((const unsigned char *)((ip + 1) + (3) / 2))[0]) : (((const unsigned char *)((ip + 1) + (3) / 2))[1])), function_int_binary); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + (((4) + 1) / 2))); else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 667 "./ipret-1.inc"
escape_int_binary_logical_thunk_0: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_int_binary_logical_operator(fp, ip, (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])), (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])), (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])), (!((3) & 1) ? (((const unsigned char *)((ip + 1) + (3) / 2))[0]) : (((const unsigned char *)((ip + 1) + (3) / 2))[1])), function_int_binary_logical); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + (((4) + 1) / 2))); else if (ex != ((void *)(uintptr_t)1)) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 677 "./ipret-1.inc"
escape_int_unary_thunk_0: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_int_unary_operator(fp, ip, (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])), (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])), (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])), function_int_unary); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + (((3) + 1) / 2))); else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 688 "./ipret-1.inc"
# 1 "./for-fix.inc" 1
# 24 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_bsr_alt1_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_alt1_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_popcnt_alt1_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_alt1_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 74 "./ipret-a1.inc" 2
# 25 "./for-fix.inc" 2
# 36 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_bsr_alt1_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_alt1_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_popcnt_alt1_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_alt1_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 74 "./ipret-a1.inc" 2
# 37 "./for-fix.inc" 2
# 48 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_bsr_alt1_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_alt1_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_popcnt_alt1_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_alt1_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 74 "./ipret-a1.inc" 2
# 49 "./for-fix.inc" 2
# 60 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_bsr_alt1_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_alt1_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_popcnt_alt1_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_alt1_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 74 "./ipret-a1.inc" 2
# 61 "./for-fix.inc" 2
# 72 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_bsr_alt1_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_alt1_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_popcnt_alt1_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_alt1_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 74 "./ipret-a1.inc" 2
# 73 "./for-fix.inc" 2
# 689 "./ipret-1.inc" 2


# 1 "./for-int.inc" 1
# 24 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_int_binary_popcnt_alt1_int8_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_alt1_int8_t_0: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_alt1_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_alt1_int8_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 38 "./ipret-a2.inc" 2
# 25 "./for-int.inc" 2
# 36 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_int_binary_popcnt_alt1_int16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_alt1_int16_t_0: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_alt1_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_alt1_int16_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 38 "./ipret-a2.inc" 2
# 37 "./for-int.inc" 2
# 48 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_int_binary_popcnt_alt1_int32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_alt1_int32_t_0: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_alt1_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_alt1_int32_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 38 "./ipret-a2.inc" 2
# 49 "./for-int.inc" 2
# 60 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_int_binary_popcnt_alt1_int64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_alt1_int64_t_0: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_alt1_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_alt1_int64_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 38 "./ipret-a2.inc" 2
# 61 "./for-int.inc" 2
# 72 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_int_binary_popcnt_alt1_int128_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_alt1_int128_t_0: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_alt1_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_alt1_int128_t_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 38 "./ipret-a2.inc" 2
# 73 "./for-int.inc" 2
# 692 "./ipret-1.inc" 2


# 1 "./for-real.inc" 1
# 23 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_add_alt1_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_subtract_alt1_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_multiply_alt1_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_divide_alt1_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_equal_alt1_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_not_equal_alt1_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_alt1_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_equal_alt1_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 118 "./ipret-a3.inc" 2
# 149 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_to_int_alt1_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_alt1_real16_t((((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 150 "./ipret-a3.inc" 2
# 163 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_from_int_alt1_real16_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_alt1_real16_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 164 "./ipret-a3.inc" 2
# 24 "./for-real.inc" 2
# 33 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_add_alt1_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_add_alt2_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_subtract_alt1_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_subtract_alt2_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_multiply_alt1_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_multiply_alt2_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_divide_alt1_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_divide_alt2_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_equal_alt1_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_equal_alt2_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_not_equal_alt1_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_not_equal_alt2_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_alt1_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_alt2_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_equal_alt1_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_equal_alt2_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 118 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_neg_alt1_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_alt1_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 125 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_neg_alt2_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_alt2_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 131 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_sqrt_alt1_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_alt1_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 137 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_sqrt_alt2_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_alt2_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 143 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_to_int_alt1_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_alt1_real32_t((((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 150 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_to_int_alt2_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_alt2_real32_t((((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 157 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_from_int_alt1_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_alt1_real32_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 164 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_from_int_alt2_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_alt2_real32_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 171 "./ipret-a3.inc" 2







# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_is_exception_alt1_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_alt1_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 179 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_is_exception_alt2_real32_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_alt2_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 185 "./ipret-a3.inc" 2
# 34 "./for-real.inc" 2
# 43 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_add_alt1_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_add_alt2_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_subtract_alt1_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_subtract_alt2_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_multiply_alt1_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_multiply_alt2_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_divide_alt1_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_divide_alt2_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_equal_alt1_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_equal_alt2_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_not_equal_alt1_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_not_equal_alt2_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_alt1_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_alt2_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_equal_alt1_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_equal_alt2_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_0; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_0; } __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 118 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_neg_alt1_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_alt1_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 125 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_neg_alt2_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_alt2_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 131 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_sqrt_alt1_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_alt1_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 137 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_sqrt_alt2_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_alt2_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 143 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_to_int_alt1_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_alt1_real64_t((((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 150 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_to_int_alt2_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_alt2_real64_t((((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 157 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_from_int_alt1_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_alt1_real64_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 164 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_from_int_alt2_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_0; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_alt2_real64_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 171 "./ipret-a3.inc" 2







# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_is_exception_alt1_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_alt1_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 179 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_is_exception_alt2_real64_t_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_0; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_alt2_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 185 "./ipret-a3.inc" 2
# 44 "./for-real.inc" 2
# 53 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 54 "./for-real.inc" 2
# 695 "./ipret-1.inc" 2

}
# 748 "./ipret-1.inc"
label_bool_binary_and_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { ((void)(zero_())); goto escape_bool_binary_thunk_0; } else { ajla_flat_option_t val1; ajla_flat_option_t val2; ajla_flat_option_t result; __asm__ volatile ("":::"memory"); val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); val2 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); result = val1 & val2; *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = result; __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
label_bool_binary_or_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { ((void)(zero_())); goto escape_bool_binary_thunk_0; } else { ajla_flat_option_t val1; ajla_flat_option_t val2; ajla_flat_option_t result; __asm__ volatile ("":::"memory"); val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); val2 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); result = val1 | val2; *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = result; __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
label_bool_binary_equal_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { ((void)(zero_())); goto escape_bool_binary_thunk_0; } else { ajla_flat_option_t val1; ajla_flat_option_t val2; ajla_flat_option_t result; __asm__ volatile ("":::"memory"); val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); val2 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); result = val1 == val2; *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = result; __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
label_bool_binary_not_equal_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { ((void)(zero_())); goto escape_bool_binary_thunk_0; } else { ajla_flat_option_t val1; ajla_flat_option_t val2; ajla_flat_option_t result; __asm__ volatile ("":::"memory"); val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); val2 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); result = val1 ^ val2; *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = result; __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
label_bool_binary_less_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { ((void)(zero_())); goto escape_bool_binary_thunk_0; } else { ajla_flat_option_t val1; ajla_flat_option_t val2; ajla_flat_option_t result; __asm__ volatile ("":::"memory"); val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); val2 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); result = val1 < val2; *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = result; __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
label_bool_binary_less_equal_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_2 = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); frame_t slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { ((void)(zero_())); goto escape_bool_binary_thunk_0; } else { ajla_flat_option_t val1; ajla_flat_option_t val2; ajla_flat_option_t result; __asm__ volatile ("":::"memory"); val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); val2 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); result = val1 <= val2; *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = result; __asm__ volatile ("":::"memory"); (ip += (1 + (((4) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
label_bool_unary_not_0: do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_bool_unary_thunk_0; } else { ajla_flat_option_t val1; ajla_flat_option_t result; __asm__ volatile ("":::"memory"); val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); result = val1 ^ 1; *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = result; __asm__ volatile ("":::"memory"); (ip += (1 + (((3) + 1) / 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

escape_bool_binary_thunk_0: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_bool_operator(fp, ip, (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])), (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])), (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])), (!((3) & 1) ? (((const unsigned char *)((ip + 1) + (3) / 2))[0]) : (((const unsigned char *)((ip + 1) + (3) / 2))[1]))); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + (((4) + 1) / 2))); else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 766 "./ipret-1.inc"
escape_bool_unary_thunk_0: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_bool_operator(fp, ip, (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])), ((frame_t)-1), (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])), (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]))); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + (((3) + 1) / 2))); else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 777 "./ipret-1.inc"
label_bool_move_0: do {

 do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0);

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_bool_copy_0: do {

 do { frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])); frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (((2) + 1) / 2))); } while (0);

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


label_OPCODE_INT_LDC_LONG0: do {

 frame_t slot;
 ip_t sz;
 slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 sz = u_ipret_int_ldc_long(fp, slot, ip + 1 + (((1) + 1) / 2));
 (ip += (1 + (((1) + 1) / 2)));
 (ip += (sz));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


label_OPCODE_IS_EXCEPTION0: do {

 frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 ((void)(zero_()));
 if (!frame_variable_is_flat(fp, slot_1)) {
  void *ex = u_is_thunk_operator(fp, ip, slot_1, slot_r, (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])));
  if (ex == ((void *)(uintptr_t)3))
   (ip += (1 + (((3) + 1) / 2)));
  else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0)))
   do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
 } else {
  __asm__ volatile ("":::"memory");
  *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = 0;
  __asm__ volatile ("":::"memory");
  (ip += (1 + (((3) + 1) / 2)));
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_EXCEPTION_CLASS0: do {

 void *ex;
 ex = u_thunk_get_param(fp, ip, (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])), (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])), (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])), 0);
 if ((__builtin_expect((int)(ex == ((void *)(uintptr_t)3)), 1)))
  (ip += (1 + (((3) + 1) / 2)));
 else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_EXCEPTION_TYPE0: do {

 void *ex;
 ex = u_thunk_get_param(fp, ip, (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])), (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])), (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])), 1);
 if ((__builtin_expect((int)(ex == ((void *)(uintptr_t)3)), 1)))
  (ip += (1 + (((3) + 1) / 2)));
 else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_EXCEPTION_AUX0: do {

 void *ex;
 ex = u_thunk_get_param(fp, ip, (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])), (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])), (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])), 2);
 if ((__builtin_expect((int)(ex == ((void *)(uintptr_t)3)), 1)))
  (ip += (1 + (((3) + 1) / 2)));
 else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_SYSTEM_PROPERTY0: do {

 void *ex;
 ex = u_ipret_get_system_property(fp, ip, (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1])), (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])));
 if ((__builtin_expect((int)(ex == ((void *)(uintptr_t)3)), 1)))
  (ip += (1 + (((3) + 1) / 2)));
 else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


label_OPCODE_FLAT_MOVE0: do {

 frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 if ((__builtin_expect((int)(frame_variable_is_flat(fp, slot_1)), 1))) {
  memcpy((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), frame_get_type_of_local(fp, slot_1)->size);
 } else {
  pointer_t ptr = frame_get_pointer_reference(fp, slot_1, 1);
  frame_set_pointer(fp, slot_r, ptr);
 }
 (ip += (1 + (((2) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_FLAT_COPY0: do {

 frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 if ((__builtin_expect((int)(frame_variable_is_flat(fp, slot_1)), 1))) {
  memcpy((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), frame_get_type_of_local(fp, slot_1)->size);
 } else {
  pointer_t ptr = frame_get_pointer_reference(fp, slot_1, 0);
  frame_set_pointer(fp, slot_r, ptr);
 }
 (ip += (1 + (((2) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_REF_MOVE0: do {

 frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 pointer_t ptr = frame_get_pointer_reference(fp, slot_1, 1);
 pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))));
 frame_set_pointer(fp, slot_r, ptr);
 (ip += (1 + (((2) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_REF_MOVE_CLEAR0: do {

 frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 pointer_t ptr = frame_get_pointer_reference(fp, slot_1, 1);
 frame_set_pointer(fp, slot_r, ptr);
 (ip += (1 + (((2) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_REF_COPY0: do {

 frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 pointer_t ptr = frame_get_pointer_reference(fp, slot_1, 0);
 frame_set_pointer(fp, slot_r, ptr);
 (ip += (1 + (((2) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_BOX_MOVE_CLEAR0: do {

 frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 pointer_t ptr = u_ipret_copy_variable_to_pointer(fp, slot_1, 1);
 *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = pointer_empty();
 frame_set_pointer(fp, slot_r, ptr);
 (ip += (1 + (((2) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_BOX_COPY0: do {

 frame_t slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 frame_t slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 pointer_t ptr = u_ipret_copy_variable_to_pointer(fp, slot_1, 0);
 frame_set_pointer(fp, slot_r, ptr);
 (ip += (1 + (((2) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_TAKE_BORROWED0: do {

 frame_t slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 if (!frame_test_and_set_flag(fp, slot)) {
  pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
  pointer_reference_owned(ptr);
 }
 (ip += (1 + (((1) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


label_OPCODE_DEREFERENCE0: do {

 frame_t slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
# 971 "./ipret-1.inc"
 frame_free(fp, slot);
 pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))));
 (ip += (1 + (((1) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_DEREFERENCE_CLEAR0: do {

 frame_t slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
# 989 "./ipret-1.inc"
 frame_free_and_clear(fp, slot);
 (ip += (1 + (((1) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_EVAL0: do {

 frame_t slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 if (frame_test_flag(fp, slot)) {
  pointer_t *ptr = (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
  struct data __attribute__((__unused__)) *result;

  do { pointer_t p_; if (!(1)) p_ = pointer_locked_read(ptr); else p_ = *(ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (result) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1003"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(ptr, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(ptr) , "./ipret-1.inc" ":" "1003"); { goto eval_skip_0; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);
# 1010 "./ipret-1.inc"
eval_skip_0:;
 }
 (ip += (1 + (((1) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


label_OPCODE_CHECKPOINT0: do {


 frame_t id = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 const code_t __attribute__((__unused__)) *orig_ip = ip;

 (ip += (1 + (((1) + 1) / 2)));

 if ((__builtin_expect((int)(((__builtin_expect((int)(*(&ts) != __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)), 0)))), 0)) && (__builtin_expect((int)(frame_execution_control(fp) != ((void*)0)), 1))) {
  do { void *ex_ = u_ipret_tick(fp, ip); do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0);
 } else {

  struct data *fn = (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function;
  code_return_t r;
  void *new_fp;
  ip_t new_ip;
  struct data *codegen;
  if ((__builtin_expect((int)(__c11_atomic_load(&((((void)(zero_()))), &(fn)->u_.function)->codegen_failed, 0)), 0)))
   goto checkpoint_exit_0;

  do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(&((((void)(zero_()))), &(fn)->u_.function)->codegen); else p_ = *(&((((void)(zero_()))), &(fn)->u_.function)->codegen); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (codegen) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1041"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(&((((void)(zero_()))), &(fn)->u_.function)->codegen, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(&((((void)(zero_()))), &(fn)->u_.function)->codegen) , "./ipret-1.inc" ":" "1041"); { __c11_atomic_store(&((((void)(zero_()))), &(fn)->u_.function)->codegen_failed, 1, 0); goto checkpoint_exit_0;; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, orig_ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);
# 1068 "./ipret-1.inc"
  r = u_codegen_entry(fp, &u_cg_upcall_vector, ts, ((((void)(zero_()))), &(codegen)->u_.codegen)->unoptimized_code[id]);
# 1078 "./ipret-1.inc"
  new_fp = r.fp;
  new_ip = r.ip;


  if ((__builtin_expect((int)(new_ip == (ip_t)-1), 0))) {

   do { if ((new_fp) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((new_fp)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((new_fp)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
  } else {

   fp = new_fp;
   ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + new_ip;
   if ((__builtin_expect((int)(profiling_escapes), 0))) {
    profile_counter_t profiling_counter;
    fn = (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function;
    profiling_counter = __c11_atomic_load(&((((void)(zero_()))), &(fn)->u_.function)->escape_data[new_ip].counter, 0);
    profiling_counter++;
    __c11_atomic_store(&((((void)(zero_()))), &(fn)->u_.function)->escape_data[new_ip].counter, profiling_counter, 0);
   }
  }

  goto checkpoint_exit_0;
checkpoint_exit_0:;
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;



label_OPCODE_JMP0: do {

 if (4 == 2) {
  int16_t offset = ip[1];
  (ip += (2));
  ip = ((const code_t *)(void *)(((const char *)(void *)(ip)) + offset));
 } else if (4 == 4) {
  int32_t offset = get_unaligned_32(&ip[1]);
  (ip += (3));
  ip = ((const code_t *)(void *)(((const char *)(void *)(ip)) + offset));
 } else {
  not_reached();
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;



label_OPCODE_JMP_BACK_160: do {

 uint16_t offset;

 offset = ip[1];
 ip = ((const code_t *)(void *)(((const char *)(void *)(ip)) - offset));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


label_OPCODE_JMP_FALSE0: do {

 int32_t offset;
 frame_t slot;
 ajla_flat_option_t val1;

 slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 if ((__builtin_expect((int)(frame_test_flag(fp, slot)), 0))) {
  void *ex = u_thunk_bool_jump(fp, ip, slot);
  if (ex != ((void *)(uintptr_t)1)) {
   if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)2)), 1))) {
    do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
   } else {
    if (4 == 2) {
     offset = ip[1 + (((1) + 1) / 2) + 1];
     (ip += (1 + (((1) + 1) / 2)));
     (ip += (2));
    } else if (4 == 4) {
     offset = get_unaligned_32(&ip[1 + (((1) + 1) / 2) + 2]);
     (ip += (1 + (((1) + 1) / 2)));
     (ip += (4));
    } else {
     not_reached();
    }
    ip = ((const code_t *)(void *)(((const char *)(void *)(ip)) + offset));
    goto jmp_false_exception_0;
   }
  }
 }
 __asm__ volatile ("":::"memory");
 val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
 __asm__ volatile ("":::"memory");
 if (4 == 2) {
  offset = ip[1 + (((1) + 1) / 2)];
  (ip += (1 + (((1) + 1) / 2)));
  (ip += (2));
 } else if (4 == 4) {
  offset = get_unaligned_32(&ip[1 + (((1) + 1) / 2)]);
  (ip += (1 + (((1) + 1) / 2)));
  (ip += (4));
 } else {
  not_reached();
 }
 if (!val1)
  ip = ((const code_t *)(void *)(((const char *)(void *)(ip)) + offset));

jmp_false_exception_0:;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


label_OPCODE_LABEL0: do {

 (ip += (1));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;



{ pointer_t *direct_data; pointer_t indirect_data; arg_t n_arguments; frame_t result_slot; struct thunk *function_error;







label_OPCODE_LOAD_FN0: do {

 struct data *new_reference;
 pointer_t result_ptr;

 n_arguments = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 result_slot = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 direct_data = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->local_directory[(!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]))];
 indirect_data = pointer_empty();

 (ip += (1 + (((3) + 1) / 2)));

fn_copy_arguments_0:

 new_reference = u_data_alloc_function_reference_mayfail(n_arguments, &ajla_error , "./ipret-1.inc" ":" "1215");
 if ((__builtin_expect((int)(!new_reference), 0))) {
  function_error = u_thunk_alloc_exception_error(ajla_error, ((void*)0), fp, ip , "./ipret-1.inc" ":" "1217");
  if (!direct_data)
   u_pointer_dereference_(indirect_data , "./ipret-1.inc" ":" "1219");

  ip = free_parameters_0(fp, ip, n_arguments);
  result_ptr = pointer_thunk(function_error);
 } else {
  arg_t i;
  if (direct_data) {
   ((((void)(zero_()))), &(new_reference)->u_.function_reference)->is_indirect = 0;
   ((((void)(zero_()))), &(new_reference)->u_.function_reference)->u.direct = direct_data;
  } else {
   ((((void)(zero_()))), &(new_reference)->u_.function_reference)->is_indirect = 1;
   ((((void)(zero_()))), &(new_reference)->u_.function_reference)->u.indirect = indirect_data;
  }
  for (i = 0; i < n_arguments; i++) {
   u_ipret_fill_function_reference_from_slot(new_reference, i, fp, (!((0) & 1) ? (((const unsigned char *)((ip) + (0) / 2))[0]) : (((const unsigned char *)((ip) + (0) / 2))[1])), ((!((1) & 1) ? (((const unsigned char *)((ip) + (1) / 2))[0]) : (((const unsigned char *)((ip) + (1) / 2))[1])) & 0x0002) != 0);
   (ip += ((((2) + 1) / 2)));
  }
  result_ptr = pointer_data(new_reference);
 }

 frame_set_pointer(fp, result_slot, result_ptr);

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CURRY0: do {

 frame_t fn_ref_slot;

 n_arguments = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 result_slot = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));

 fn_ref_slot = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]));
 direct_data = ((void*)0);
 indirect_data = frame_get_pointer_reference(fp, fn_ref_slot, ((!((3) & 1) ? (((const unsigned char *)((ip + 1) + (3) / 2))[0]) : (((const unsigned char *)((ip + 1) + (3) / 2))[1])) & 0x0002) != 0);

 (ip += (1 + (((4) + 1) / 2)));

 goto fn_copy_arguments_0;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

}

{ arg_t n_arguments; arg_t n_return_values; struct thunk *function_error; struct data *function; const code_t *orig_ip; frame_s *new_fp; arg_t i; pointer_t *direct_function; pointer_t indirect_function; unsigned char mode;
# 1274 "./ipret-1.inc"
label_OPCODE_CALL0: do {

 pointer_t *function_ptr;

 mode = 1;
call_from_mode_0:

 n_arguments = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 n_return_values = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 function_ptr = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->local_directory[(!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]))];

 do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(function_ptr); else p_ = *(function_ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (function) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1291"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(function_ptr, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(function_ptr) , "./ipret-1.inc" ":" "1291"); { function_error = thunk_; thunk_reference(function_error); (ip += (1 + (((3) + 1) / 2))); goto call_set_error_0;; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);







 ((void)(zero_()));





 (ip += (1 + (((3) + 1) / 2)));

 new_fp = frame_build(fp, function, &ajla_error);
 if ((__builtin_expect((int)(!new_fp), 0))) {
call_allocation_error_0:
  function_error = u_thunk_alloc_exception_error(ajla_error, ((void*)0), fp, ip , "./ipret-1.inc" ":" "1304");
call_set_error_0:
  ip = free_parameters_0(fp, ip, n_arguments);
  pointer_reference_owned_multiple(pointer_thunk(function_error), n_return_values - 1);
  i = n_return_values;
  while (1) {
   frame_t slot_r = get_unaligned_32(&(ip)[(0) * 2]);
   (ip += (((1) * 2) + 1));
   frame_set_pointer(fp, slot_r, pointer_thunk(function_error));
   if (!--i)
    break;
  }
 } else {
  fp = frame_up(new_fp);
  frame_init(new_fp, function, (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->timestamp, mode);

  i = 0;
call_copy_arguments_0:
  for (; i < ((((void)(zero_()))), &(function)->u_.function)->n_arguments; i++) {
   frame_t src_slot = (!((0) & 1) ? (((const unsigned char *)((ip) + (0) / 2))[0]) : (((const unsigned char *)((ip) + (0) / 2))[1]));
   frame_t dst_slot = ((((void)(zero_()))), &(function)->u_.function)->args[i].slot;
   unsigned char src_flag = (unsigned char)(!((1) & 1) ? (((const unsigned char *)((ip) + (1) / 2))[0]) : (((const unsigned char *)((ip) + (1) / 2))[1]));
   _Bool may_be_borrowed = ((((void)(zero_()))), &(function)->u_.function)->args[i].may_be_borrowed;
   if (may_be_borrowed && src_flag & 0x0004 && !pointer_is_thunk(*(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(src_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))))) {
    *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(new_fp))) + ((size_t)(dst_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(src_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
   } else if (may_be_borrowed && src_flag & 0x0008 && !frame_test_flag(fp, src_slot) && !pointer_is_thunk(*(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(src_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))))) {
    *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(new_fp))) + ((size_t)(dst_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(src_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
    *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(src_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = pointer_empty();
   } else {
    u_ipret_copy_variable(fp, src_slot, new_fp, dst_slot, (src_flag & 0x0002) != 0);
   }
   (ip += ((((2) + 1) / 2)));
  }
  (((struct frame_struct *)(void *)(((const char *)(void *)(new_fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->previous_ip = frame_ip(fp, ip);

  fp = new_fp;
  ip = &((((void)(zero_()))), &(function)->u_.function)->code[0];

  if ((__builtin_expect((int)(mode == 3), 0))) {
   do { void *ex_ = u_ipret_tick(fp, ip); do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0);
  }
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_STRICT0: do {

 mode = 2;
 goto call_from_mode_0;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_SPARK0: do {

 mode = 3;
 goto call_from_mode_0;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_INDIRECT0: do {

 frame_t fn_ref_slot;
 _Bool deref;
 pointer_t *ptr;

 mode = 1;
call_indirect_from_mode_0:

 orig_ip = ip;
 n_arguments = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 n_return_values = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 fn_ref_slot = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]));
 deref = ((!((3) & 1) ? (((const unsigned char *)((ip + 1) + (3) / 2))[0]) : (((const unsigned char *)((ip + 1) + (3) / 2))[1])) & 0x0002) != 0;
 (ip += (1 + (((4) + 1) / 2)));

 ptr = (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(fn_ref_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
 while (1) {
  do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(ptr); else p_ = *(ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (function) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1388"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(ptr, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(ptr) , "./ipret-1.inc" ":" "1388"); { function_error = thunk_; thunk_reference(function_error); if (deref) frame_free_and_clear(fp, fn_ref_slot); goto call_set_error_0; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, orig_ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);







  if (!((((void)(zero_()))), &(function)->u_.function_reference)->is_indirect)
   break;
  ptr = &((((void)(zero_()))), &(function)->u_.function_reference)->u.indirect;
 }
 ptr = ((((void)(zero_()))), &(function)->u_.function_reference)->u.direct;
 do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(ptr); else p_ = *(ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (function) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1401"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(ptr, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(ptr) , "./ipret-1.inc" ":" "1401"); { function_error = thunk_; thunk_reference(function_error); if (deref) frame_free_and_clear(fp, fn_ref_slot); goto call_set_error_0; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, orig_ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);
# 1403 "./ipret-1.inc"
 new_fp = frame_build(fp, function, &ajla_error);
 if ((__builtin_expect((int)(!new_fp), 0))) {
  if (deref)
   frame_free_and_clear(fp, fn_ref_slot);
  goto call_allocation_error_0;
 } else {
  fp = frame_up(new_fp);
  frame_init(new_fp, function, (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->timestamp, mode);

  i = ((((void)(zero_()))), &(function)->u_.function)->n_arguments - n_arguments;

  u_copy_from_function_reference_to_frame(new_fp, pointer_get_data_(*(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(fn_ref_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) , "./ipret-1.inc" ":" "1414"), i, deref && frame_test_flag(fp, fn_ref_slot));
  if (deref)
   frame_free_and_clear(fp, fn_ref_slot);

  goto call_copy_arguments_0;
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_INDIRECT_STRICT0: do {

 mode = 2;
 goto call_indirect_from_mode_0;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_INDIRECT_SPARK0: do {

 mode = 3;
 goto call_indirect_from_mode_0;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_LAZY0: do {

 struct data *function_reference;
 struct thunk **results;

 n_arguments = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 n_return_values = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 direct_function = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->local_directory[(!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]))];
 indirect_function = pointer_empty();

 (ip += (1 + (((3) + 1) / 2)));

call_lazy_copy_arguments_0:
 results = ((__builtin_expect((int)(!mem_check_overflow(0, n_return_values, sizeof(struct thunk *), &ajla_error)), 0)) ? ((struct thunk **)(void *)(((void*)0))) : ((struct thunk **)(void *)(mem_alloc_position((((size_t)(0) + (size_t)(n_return_values) * (size_t)(sizeof(struct thunk *))) >= ((size_t)(0)) + (zero_()) ? ((size_t)(0) + (size_t)(n_return_values) * (size_t)(sizeof(struct thunk *))) : ((size_t)(0))), &ajla_error , "./ipret-1.inc" ":" "1450"))));
 if ((__builtin_expect((int)(!results), 0))) {
  if (!direct_function)
   u_pointer_dereference_(indirect_function , "./ipret-1.inc" ":" "1453");
  goto call_allocation_error_0;
 }

 if (!(function_reference = u_data_alloc_function_reference_mayfail(n_arguments, &ajla_error , "./ipret-1.inc" ":" "1457"))) {
  if (!direct_function)
   u_pointer_dereference_(indirect_function , "./ipret-1.inc" ":" "1459");
  mem_free_position(results , "./ipret-1.inc" ":" "1460");
  goto call_allocation_error_0;
 }
 if (direct_function) {
  ((((void)(zero_()))), &(function_reference)->u_.function_reference)->is_indirect = 0;
  ((((void)(zero_()))), &(function_reference)->u_.function_reference)->u.direct = direct_function;
 } else {
  ((((void)(zero_()))), &(function_reference)->u_.function_reference)->is_indirect = 1;
  ((((void)(zero_()))), &(function_reference)->u_.function_reference)->u.indirect = indirect_function;
 }

 if (!u_thunk_alloc_function_call(pointer_data(function_reference), n_return_values, results, &ajla_error)) {
  if (!direct_function)
   u_pointer_dereference_(indirect_function , "./ipret-1.inc" ":" "1473");
  mem_free_position(results , "./ipret-1.inc" ":" "1474");
  do { ((void)(zero_())); do { refcount_poison_tag_(&(function_reference)->refcount_, "./ipret-1.inc" ":" "1475");; mem_free_aligned_position(data_untag_(function_reference, "./ipret-1.inc" ":" "1475") , "./ipret-1.inc" ":" "1475"); } while (0); } while (0);
  goto call_allocation_error_0;
 }

 for (i = 0; i < n_arguments; i++) {
  frame_t src_slot = (!((0) & 1) ? (((const unsigned char *)((ip) + (0) / 2))[0]) : (((const unsigned char *)((ip) + (0) / 2))[1]));
  unsigned char src_flag = (unsigned char)(!((1) & 1) ? (((const unsigned char *)((ip) + (1) / 2))[0]) : (((const unsigned char *)((ip) + (1) / 2))[1]));
  u_ipret_fill_function_reference_from_slot(function_reference, i, fp, src_slot, (src_flag & 0x0002) != 0);
  (ip += ((((2) + 1) / 2)));
 }

 for (i = 0; i < n_return_values; i++) {
  frame_t slot_r = get_unaligned_32(&(ip)[(0) * 2]);
  frame_set_pointer(fp, slot_r, pointer_thunk(results[i]));
  (ip += (((1) * 2) + 1));
 }

 mem_free_position(results , "./ipret-1.inc" ":" "1492");

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_INDIRECT_LAZY0: do {

 frame_t fn_ref_slot;
 _Bool deref;

 n_arguments = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 n_return_values = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 fn_ref_slot = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]));
 deref = ((!((3) & 1) ? (((const unsigned char *)((ip + 1) + (3) / 2))[0]) : (((const unsigned char *)((ip + 1) + (3) / 2))[1])) & 0x0002) != 0;
 (ip += (1 + (((4) + 1) / 2)));

 indirect_function = frame_get_pointer_reference(fp, fn_ref_slot, deref);
 direct_function = ((void*)0);

 goto call_lazy_copy_arguments_0;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_CACHE0: do {

 struct ipret_call_cache_arg *arguments;
 frame_t *return_values;
 void *ex;

call_cache_0:
 orig_ip = ip;
 n_arguments = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 n_return_values = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 direct_function = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->local_directory[(!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]))];
 (ip += (1 + (((3) + 1) / 2)));

 do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(direct_function); else p_ = *(direct_function); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (function) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1532"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(direct_function, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(direct_function) , "./ipret-1.inc" ":" "1532"); { function_error = thunk_; thunk_reference(function_error); goto call_set_error_0;; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, orig_ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);





 ((void)(zero_()));




 arguments = ((__builtin_expect((int)(!mem_check_overflow(0, n_arguments, sizeof(struct ipret_call_cache_arg), &ajla_error)), 0)) ? ((struct ipret_call_cache_arg *)(void *)(((void*)0))) : ((struct ipret_call_cache_arg *)(void *)(mem_alloc_position((((size_t)(0) + (size_t)(n_arguments) * (size_t)(sizeof(struct ipret_call_cache_arg))) >= ((size_t)(0)) + (zero_()) ? ((size_t)(0) + (size_t)(n_arguments) * (size_t)(sizeof(struct ipret_call_cache_arg))) : ((size_t)(0))), &ajla_error , "./ipret-1.inc" ":" "1538"))));
 if (!arguments) {
  goto call_allocation_error_0;
 }
 return_values = ((__builtin_expect((int)(!mem_check_overflow(0, n_return_values, sizeof(frame_t), &ajla_error)), 0)) ? ((frame_t *)(void *)(((void*)0))) : ((frame_t *)(void *)(mem_alloc_position((((size_t)(0) + (size_t)(n_return_values) * (size_t)(sizeof(frame_t))) >= ((size_t)(0)) + (zero_()) ? ((size_t)(0) + (size_t)(n_return_values) * (size_t)(sizeof(frame_t))) : ((size_t)(0))), &ajla_error , "./ipret-1.inc" ":" "1542"))));
 if (!return_values) {
  mem_free_position(arguments , "./ipret-1.inc" ":" "1544");
  goto call_allocation_error_0;
 }

 for (i = 0; i < n_arguments; i++) {
  frame_t src_slot = (!((0) & 1) ? (((const unsigned char *)((ip) + (0) / 2))[0]) : (((const unsigned char *)((ip) + (0) / 2))[1]));
  unsigned char src_flag = (unsigned char)(!((1) & 1) ? (((const unsigned char *)((ip) + (1) / 2))[0]) : (((const unsigned char *)((ip) + (1) / 2))[1]));
  arguments[i].f_arg = ((void*)0);
  arguments[i].slot = src_slot;
  arguments[i].deref = (src_flag & 0x0002) != 0;
  (ip += ((((2) + 1) / 2)));
 }

 for (i = 0; i < n_return_values; i++) {
  frame_t slot_r = get_unaligned_32(&(ip)[(0) * 2]);
  return_values[i] = slot_r;
  (ip += (((1) * 2) + 1));
 }

 ex = u_ipret_call_cache(fp, orig_ip, direct_function, arguments, return_values, ((frame_t)-1));
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0))) {
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_SAVE0: do {

 goto call_cache_0;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_INDIRECT_CACHE0: do {

 struct ipret_call_cache_arg *arguments;
 frame_t *return_values;
 void *ex;

 frame_t fn_ref_slot;
 _Bool deref;
 pointer_t *ptr;
 arg_t n_curried_arguments;

call_indirect_cache_0:
 orig_ip = ip;
 n_arguments = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 n_return_values = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 fn_ref_slot = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]));
 deref = ((!((3) & 1) ? (((const unsigned char *)((ip + 1) + (3) / 2))[0]) : (((const unsigned char *)((ip + 1) + (3) / 2))[1])) & 0x0002) != 0;
 (ip += (1 + (((4) + 1) / 2)));

 n_curried_arguments = 0;
 ptr = (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(fn_ref_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
 while (1) {
  do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(ptr); else p_ = *(ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (function) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1605"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(ptr, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(ptr) , "./ipret-1.inc" ":" "1605"); { function_error = thunk_; thunk_reference(function_error); if (deref) frame_free_and_clear(fp, fn_ref_slot); goto call_set_error_0; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, orig_ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);







  n_curried_arguments += ((((void)(zero_()))), &(function)->u_.function_reference)->n_curried_arguments;
  if (!((((void)(zero_()))), &(function)->u_.function_reference)->is_indirect)
   break;
  ptr = &((((void)(zero_()))), &(function)->u_.function_reference)->u.indirect;
 }
 ptr = ((((void)(zero_()))), &(function)->u_.function_reference)->u.direct;
 do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(ptr); else p_ = *(ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (function) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1619"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(ptr, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(ptr) , "./ipret-1.inc" ":" "1619"); { function_error = thunk_; thunk_reference(function_error); if (deref) frame_free_and_clear(fp, fn_ref_slot); goto call_set_error_0; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, orig_ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);
# 1621 "./ipret-1.inc"
 arguments = ((__builtin_expect((int)(!mem_check_overflow(0, n_curried_arguments + n_arguments, sizeof(struct ipret_call_cache_arg), &ajla_error)), 0)) ? ((struct ipret_call_cache_arg *)(void *)(((void*)0))) : ((struct ipret_call_cache_arg *)(void *)(mem_alloc_position((((size_t)(0) + (size_t)(n_curried_arguments + n_arguments) * (size_t)(sizeof(struct ipret_call_cache_arg))) >= ((size_t)(0)) + (zero_()) ? ((size_t)(0) + (size_t)(n_curried_arguments + n_arguments) * (size_t)(sizeof(struct ipret_call_cache_arg))) : ((size_t)(0))), &ajla_error , "./ipret-1.inc" ":" "1621"))));
 if (!arguments) {
  if (deref)
   frame_free_and_clear(fp, fn_ref_slot);
  goto call_allocation_error_0;
 }
 return_values = ((__builtin_expect((int)(!mem_check_overflow(0, n_return_values, sizeof(frame_t), &ajla_error)), 0)) ? ((frame_t *)(void *)(((void*)0))) : ((frame_t *)(void *)(mem_alloc_position((((size_t)(0) + (size_t)(n_return_values) * (size_t)(sizeof(frame_t))) >= ((size_t)(0)) + (zero_()) ? ((size_t)(0) + (size_t)(n_return_values) * (size_t)(sizeof(frame_t))) : ((size_t)(0))), &ajla_error , "./ipret-1.inc" ":" "1627"))));
 if (!return_values) {
  mem_free_position(arguments , "./ipret-1.inc" ":" "1629");
  if (deref)
   frame_free_and_clear(fp, fn_ref_slot);
  goto call_allocation_error_0;
 }

 i = n_curried_arguments;
 function = pointer_get_data_(*(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(fn_ref_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) , "./ipret-1.inc" ":" "1636");
 while (1) {
  arg_t j;
  j = ((((void)(zero_()))), &(function)->u_.function_reference)->n_curried_arguments;
  while (j--) {
   i--;
   arguments[i].f_arg = &((((void)(zero_()))), &(function)->u_.function_reference)->arguments[j];
   arguments[i].deref = 0;
  }
  if (!((((void)(zero_()))), &(function)->u_.function_reference)->is_indirect)
   break;
  function = pointer_get_data_(((((void)(zero_()))), &(function)->u_.function_reference)->u.indirect , "./ipret-1.inc" ":" "1647");
 }

 for (i = n_curried_arguments; i < n_curried_arguments + n_arguments; i++) {
  frame_t src_slot = (!((0) & 1) ? (((const unsigned char *)((ip) + (0) / 2))[0]) : (((const unsigned char *)((ip) + (0) / 2))[1]));
  unsigned char src_flag = (unsigned char)(!((1) & 1) ? (((const unsigned char *)((ip) + (1) / 2))[0]) : (((const unsigned char *)((ip) + (1) / 2))[1]));
  arguments[i].f_arg = ((void*)0);
  arguments[i].slot = src_slot;
  arguments[i].deref = (src_flag & 0x0002) != 0;
  (ip += ((((2) + 1) / 2)));
 }

 for (i = 0; i < n_return_values; i++) {
  frame_t slot_r = get_unaligned_32(&(ip)[(0) * 2]);
  return_values[i] = slot_r;
  (ip += (((1) * 2) + 1));
 }

 ex = u_ipret_call_cache(fp, orig_ip, ptr, arguments, return_values, deref ? fn_ref_slot : ((frame_t)-1));
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0))) {
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_INDIRECT_SAVE0: do {

 goto call_indirect_cache_0;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

}

label_OPCODE_RETURN0: do {

 struct data *function;
 frame_s *previous_fp;
 const code_t *previous_ip;
 arg_t i, n;



 function = (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function;
 previous_fp = frame_up(fp);
 if ((__builtin_expect((int)(frame_is_top(previous_fp)), 0))) {
  struct execution_control *ex;
  void *exx;
  struct thunk *t;
  struct stack_bottom *sb = frame_stack_bottom(previous_fp);
  ex = sb->ex;
  if (!ex) {
   frame_t src_slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
   sb->ret = u_ipret_copy_variable_to_pointer(fp, src_slot, 1);
   goto exit_ipret;
  }
  t = ex->thunk;
  n = ((((void)(zero_()))), &(function)->u_.function)->n_return_values;
  i = 0;
  do {
   frame_t src_slot = (!((i * 2) & 1) ? (((const unsigned char *)((ip + 1) + (i * 2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (i * 2) / 2))[1]));
   frame_t flags = (!((i * 2 + 1) & 1) ? (((const unsigned char *)((ip + 1) + (i * 2 + 1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (i * 2 + 1) / 2))[1]));
   t->u.function_call.results[i].ptr = u_ipret_copy_variable_to_pointer(fp, src_slot, (flags & 0x0002) != 0);
  } while (++i < n);
  exx = u_thunk_terminate(t, n);





  do { if ((exx) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((exx)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((exx)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 }

 (((struct frame_struct *)(void *)(((const char *)(void *)(previous_fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->timestamp = (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->timestamp;
 previous_ip = &((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(previous_fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code[(((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->previous_ip];

 n = ((((void)(zero_()))), &(function)->u_.function)->n_return_values;
 i = 0;
 do {
  frame_t src_slot, dst_slot, flags;
  src_slot = (!((i * 2) & 1) ? (((const unsigned char *)((ip + 1) + (i * 2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (i * 2) / 2))[1]));
  flags = (!((i * 2 + 1) & 1) ? (((const unsigned char *)((ip + 1) + (i * 2 + 1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (i * 2 + 1) / 2))[1]));
  dst_slot = (frame_t)get_unaligned_32(&(previous_ip)[(0) * 2]);
  previous_ip += ((1) * 2) + 1;
  u_ipret_copy_variable(fp, src_slot, previous_fp, dst_slot, (flags & 0x0002) != 0);
 } while (++i < n);

 fp = previous_fp;
 ip = previous_ip;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


label_OPCODE_STRUCTURED0: do {

 const code_t *orig_ip = ip;

 frame_t struc, elem;
 pointer_t *struc_ptr;
 unsigned char *struc_flat;
 const struct type *t;
 _Bool optimize_elem_is_flat;

 unsigned char type;
 frame_t arg;

 pointer_t thunk_ptr;

 elem = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 optimize_elem_is_flat = frame_variable_is_flat(fp, elem);

structured_retry_0:
 struc = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 (ip += (1 + (((2) + 1) / 2)));

 t = frame_get_type_of_local(fp, struc);
 if (frame_variable_is_flat(fp, struc)) {
  if (!optimize_elem_is_flat) {
   frame_set_pointer(fp, struc, u_flat_to_data(frame_get_type_of_local(fp, struc), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(struc) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))));
   struc_flat = ((void*)0);
   struc_ptr = (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(struc) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
  } else {
   struc_flat = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(struc) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))));
   struc_ptr = ((void*)0);
  }
 } else {
  struc_flat = ((void*)0);
  struc_ptr = (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(struc) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
 }

 do {
  array_index_t array_index = (((uint64_t)(-((uint64_t)1 << (8 * sizeof(uint64_t) - 2)) * 2)));
  struct data *data = ((void*)0);

  type = (unsigned char)(!((0) & 1) ? (((const unsigned char *)((ip) + (0) / 2))[0]) : (((const unsigned char *)((ip) + (0) / 2))[1]));
  arg = (!((1) & 1) ? (((const unsigned char *)((ip) + (1) / 2))[0]) : (((const unsigned char *)((ip) + (1) / 2))[1]));
  (ip += ((((3) + 1) / 2)));

  if ((type & 0x0f) == 0x03) {
   void *ex = u_ipret_get_index(fp, orig_ip, fp, arg, ((void*)0), &array_index, &thunk_ptr , "./ipret-1.inc" ":" "1786");
   if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0))) {
    if (ex == ((void *)(uintptr_t)2))
     goto structured_error_0;
    do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
   }
  }

  if (struc_flat) {
   switch (type & 0x0f) {
    case 0x01: {
     const struct flat_record_definition_entry *e;
     ((void)(zero_()));
     e = &(((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1799", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->entries[arg];
     t = e->subtype;
     struc_flat += e->flat_offset;
     break;
    }
    case 0x02: {
     thunk_ptr = u_pointer_error(error_ajla_aux_(1, 10, 0 , "./ipret-1.inc" ":" "1805"), fp, ip , "./ipret-1.inc" ":" "1805");
     goto structured_error_0;
    }
    case 0x03: {
     if ((__builtin_expect((int)(index_ge_int_(array_index, (((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 4)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1809", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 4))), ((void)sizeof(&(((struct flat_array_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_array_definition, type)))))->type == (t)), (((struct flat_array_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_array_definition, type)))))))->n_elements , "./ipret-1.inc" ":" "1809")), 0))) {
      index_free_(&array_index , "./ipret-1.inc" ":" "1810");
      thunk_ptr = u_pointer_error(error_ajla_aux_(1, 9, 0 , "./ipret-1.inc" ":" "1811"), fp, ip , "./ipret-1.inc" ":" "1811");
      goto structured_error_0;
     }
     t = (((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 4)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1814", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 4))), ((void)sizeof(&(((struct flat_array_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_array_definition, type)))))->type == (t)), (((struct flat_array_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_array_definition, type)))))))->base;
     struc_flat += t->size * index_to_int_(array_index , "./ipret-1.inc" ":" "1815");
     index_free_(&array_index , "./ipret-1.inc" ":" "1816");
     break;
    }
    default:
     internal("./ipret-1.inc" ":" "1820", "structured flat: invalid structure type %02x", type);
   }
  } else {
structured_restart_pointer_follow_0:
   do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(struc_ptr); else p_ = *(struc_ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (data) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1831"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(struc_ptr, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(struc_ptr) , "./ipret-1.inc" ":" "1831"); { if ((type & 0x0f) == 0x03) index_free_(&array_index , "./ipret-1.inc" ":" "1829"); goto structured_read_to_the_end_0;; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, orig_ip); } { if ((type & 0x0f) == 0x03) index_free_(&array_index , "./ipret-1.inc" ":" "1826"); do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);







   if ((__builtin_expect((int)(!data_is_writable(data)), 0))) {
    u_struct_clone(struc_ptr);
    goto structured_restart_pointer_follow_0;
   }
   switch (type & 0x0f) {
    case 0x01: {
     const struct record_definition *def = (((__builtin_expect((int)((((((void)(zero_()))), &(data)->u_.record)->definition)->tag == ((((0 + 2 * 5) + 5) + 4) + 2)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1838", "type_def: invalid type tag %u, expected %u", (((((void)(zero_()))), &(data)->u_.record)->definition)->tag, ((((0 + 2 * 5) + 5) + 4) + 2))), ((void)sizeof(&(((struct record_definition *)(void *)((((char *)(void *)((((((void)(zero_()))), &(data)->u_.record)->definition))) - __builtin_offsetof(struct record_definition, type)))))->type == (((((void)(zero_()))), &(data)->u_.record)->definition)), (((struct record_definition *)(void *)((((char *)(void *)((((((void)(zero_()))), &(data)->u_.record)->definition))) - __builtin_offsetof(struct record_definition, type)))))));
     ((void)(zero_()));
     t = def->types[arg];
     struc_ptr = (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(da_record_frame(data)))) + ((size_t)(arg) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));

     if (type & 0x20) {
      if (frame_variable_is_flat(fp, elem)) {
       if (((((((void)(zero_())), ((t)->tag) < 0 + 2 * 5) || (((void)(zero_())), ((t)->tag) >= ((0 + 2 * 5) + 5) && ((t)->tag) < ((0 + 2 * 5) + 5) + 4) || (((void)(zero_())), ((t)->tag) >= (0 + 2 * 5) && ((t)->tag) < (0 + 2 * 5) + 5) || ((t)->tag) == ((((0 + 2 * 5) + 5) + 4) + 0)) || ((t)->tag) == ((((0 + 2 * 5) + 5) + 4) + 3) || ((t)->tag) == ((((0 + 2 * 5) + 5) + 4) + 4)))) {
        frame_free(da_record_frame(data), arg);
        struc_flat = (((unsigned char *)(void *)(((((unsigned char *)(void *)(da_record_frame(data)))) + ((size_t)(arg) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))));
        goto structured_write_flat_0;
       }
      } else {
       if (!frame_test_and_set_flag(da_record_frame(data), arg))
        goto structured_write_ptr_0;
      }
     }

     if (!frame_test_flag(da_record_frame(data), arg)) {
      struc_flat = (((unsigned char *)(void *)(((((unsigned char *)(void *)(da_record_frame(data)))) + ((size_t)(arg) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))));
      if ((__builtin_expect((int)(!optimize_elem_is_flat), 0))) {
       frame_set_pointer(da_record_frame(data), arg, u_flat_to_data(t, struc_flat));
       struc_flat = ((void*)0);
      }
     }
     break;
    }
    case 0x02: {
     if ((__builtin_expect((int)(((((void)(zero_()))), &(data)->u_.option)->option != arg), 0))) {
      if ((__builtin_expect((int)((type & 0x20) != 0), 1))) {
       ((((void)(zero_()))), &(data)->u_.option)->option = arg;
      } else {
       thunk_ptr = u_pointer_error(error_ajla_aux_(1, 10, 0 , "./ipret-1.inc" ":" "1870"), fp, ip , "./ipret-1.inc" ":" "1870");
structured_error_0:
       if (struc_flat) {
        u_pointer_dereference_(thunk_ptr , "./ipret-1.inc" ":" "1873");
        optimize_elem_is_flat = 0;
        ip = orig_ip;
        goto structured_retry_0;
       } else {
        u_pointer_dereference_(*struc_ptr , "./ipret-1.inc" ":" "1878");
        *struc_ptr = thunk_ptr;
        goto structured_read_to_the_end_0;
       }
      }
     }
     struc_ptr = &((((void)(zero_()))), &(data)->u_.option)->pointer;
     break;
    }
    case 0x03: {
     unsigned array_flags;
     if ((__builtin_expect((int)((((void)(zero_())), (refcount_tag_get((const refcount_t *)&(data)->refcount_))) == 10), 0))) {
      array_index_t len_first;

      if (u_array_incomplete_collapse(struc_ptr))
       goto structured_restart_pointer_follow_0;

      len_first = u_array_len(pointer_get_data_(((((void)(zero_()))), &(data)->u_.array_incomplete)->first , "./ipret-1.inc" ":" "1895"));
      if (!index_ge_index_(array_index, len_first , "./ipret-1.inc" ":" "1896")) {
       index_free_(&len_first , "./ipret-1.inc" ":" "1897");
       struc_ptr = &((((void)(zero_()))), &(data)->u_.array_incomplete)->first;
       goto structured_restart_pointer_follow_0;
      } else {
       index_sub_(&array_index, len_first , "./ipret-1.inc" ":" "1901");
       index_free_(&len_first , "./ipret-1.inc" ":" "1902");
       struc_ptr = &((((void)(zero_()))), &(data)->u_.array_incomplete)->next;
       goto structured_restart_pointer_follow_0;
      }
     }
     if (!optimize_elem_is_flat) {
      array_flags = 2;
     } else if (type & 0x20) {
      array_flags = 1;
      t = frame_get_type_of_local(fp, elem);
     } else {
      array_flags = 0;
     }
     if ((__builtin_expect((int)(!u_array_modify(struc_ptr, array_index, array_flags, &struc_ptr, &struc_flat, &t, fp, ip)), 0))) {
      goto structured_read_to_the_end_0;
     }
     break;
    }
    default:
     internal("./ipret-1.inc" ":" "1921", "structured: invalid structure type %02x", type);
   }
  }
 } while (!(type & 0x20));
 if (struc_flat) {
structured_write_flat_0:
  memcpy_fast(struc_flat, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(elem) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), frame_get_type_of_local(fp, elem)->size);
 } else {

  if ((__builtin_expect((int)(!pointer_is_empty(*struc_ptr)), 1)))
   u_pointer_dereference_(*struc_ptr , "./ipret-1.inc" ":" "1931");
  if (frame_variable_is_flat(fp, elem)) {
   *struc_ptr = u_flat_to_data(frame_get_type_of_local(fp, elem), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(elem) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))));
  } else {
structured_write_ptr_0:
   *struc_ptr = frame_get_pointer_reference(fp, elem, (type & 0x10) != 0);
  }
 }
 if (0) {
  do {
   type = (unsigned char)(!((0) & 1) ? (((const unsigned char *)((ip) + (0) / 2))[0]) : (((const unsigned char *)((ip) + (0) / 2))[1]));
   arg = (!((1) & 1) ? (((const unsigned char *)((ip) + (1) / 2))[0]) : (((const unsigned char *)((ip) + (1) / 2))[1]));
   (ip += ((((3) + 1) / 2)));
structured_read_to_the_end_0:;
  } while (!(type & 0x20));
  if (type & 0x10)
   frame_free(fp, elem);
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_RECORD_CREATE0: do {

 frame_t result_slot;
 arg_t n_entries, i, ii;
 const struct type *t;
 const struct record_definition *def;

 result_slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 n_entries = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 (ip += (1 + (((2) + 1) / 2)));

 t = frame_get_type_of_local(fp, result_slot);
 if (t->tag == ((((0 + 2 * 5) + 5) + 4) + 3)) {
  const code_t *backup_ip;
  def = (((__builtin_expect((int)(((((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1966", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->base)->tag == ((((0 + 2 * 5) + 5) + 4) + 2)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1966", "type_def: invalid type tag %u, expected %u", ((((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1966", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->base)->tag, ((((0 + 2 * 5) + 5) + 4) + 2))), ((void)sizeof(&(((struct record_definition *)(void *)((((char *)(void *)(((((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1966", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->base))) - __builtin_offsetof(struct record_definition, type)))))->type == ((((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1966", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->base)), (((struct record_definition *)(void *)((((char *)(void *)(((((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1966", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->base))) - __builtin_offsetof(struct record_definition, type)))))));
  backup_ip = ip;
  for (i = 0, ii = 0; i < n_entries; i++, ii++) {
   frame_t var_slot, record_slot;
   flat_size_t flat_offset;
   const struct type *flat_type;

   while ((__builtin_expect((int)(record_definition_is_elided(def, ii)), 0)))
    ii++;

   var_slot = (!((0) & 1) ? (((const unsigned char *)((ip) + (0) / 2))[0]) : (((const unsigned char *)((ip) + (0) / 2))[1]));

   if ((__builtin_expect((int)(!frame_variable_is_flat(fp, var_slot)), 0))) {
    ip = backup_ip;
    goto create_record_no_flat_0;
   }
   record_slot = record_definition_slot(def, ii);
   flat_offset = (((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1983", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->entries[record_slot].flat_offset;
   flat_type = (((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1984", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->entries[record_slot].subtype;
   ((void)(zero_()));
   memcpy_fast((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(result_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))) + flat_offset, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(var_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), flat_type->size);
   (ip += ((((2) + 1) / 2)));
  }
  ((void)(zero_()));
 } else {
  struct data *result;
  def = (((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 2)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1992", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 2))), ((void)sizeof(&(((struct record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct record_definition, type)))))->type == (t)), (((struct record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct record_definition, type)))))));
create_record_no_flat_0:
  result = u_data_alloc_record_mayfail(def, &ajla_error , "./ipret-1.inc" ":" "1994");
  if ((__builtin_expect((int)(!result), 0))) {
   ip = free_parameters_0(fp, ip, n_entries);
   frame_set_pointer(fp, result_slot, u_pointer_error(ajla_error, fp, ip , "./ipret-1.inc" ":" "1997"));
   break;
  }
  memset(da_record_frame(result), 0, (((((frame_t)(def->n_slots)) + (1 << (( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((1 << (( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * ((frame_t)(def->n_slots)))) >> (( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) * ((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))));
  for (i = 0, ii = 0; i < n_entries; i++, ii++) {
   frame_t var_slot, record_slot;
   const struct type *rec_type, *var_type;

   while ((__builtin_expect((int)(record_definition_is_elided(def, ii)), 0)))
    ii++;

   var_slot = (!((0) & 1) ? (((const unsigned char *)((ip) + (0) / 2))[0]) : (((const unsigned char *)((ip) + (0) / 2))[1]));
   record_slot = record_definition_slot(def, ii);
   rec_type = def->types[record_slot];
   var_type = frame_get_type_of_local(fp, var_slot);

   if (!frame_variable_is_flat(fp, var_slot)) {
    pointer_t ptr = frame_get_pointer_reference(fp, var_slot, ((!((1) & 1) ? (((const unsigned char *)((ip) + (1) / 2))[0]) : (((const unsigned char *)((ip) + (1) / 2))[1])) & 0x0002) != 0);
    frame_set_pointer(da_record_frame(result), record_slot, ptr);
   } else if (((((((void)(zero_())), ((rec_type)->tag) < 0 + 2 * 5) || (((void)(zero_())), ((rec_type)->tag) >= ((0 + 2 * 5) + 5) && ((rec_type)->tag) < ((0 + 2 * 5) + 5) + 4) || (((void)(zero_())), ((rec_type)->tag) >= (0 + 2 * 5) && ((rec_type)->tag) < (0 + 2 * 5) + 5) || ((rec_type)->tag) == ((((0 + 2 * 5) + 5) + 4) + 0)) || ((rec_type)->tag) == ((((0 + 2 * 5) + 5) + 4) + 3) || ((rec_type)->tag) == ((((0 + 2 * 5) + 5) + 4) + 4)))) {
    ((void)(zero_()));
    memcpy_fast((((unsigned char *)(void *)(((((unsigned char *)(void *)(da_record_frame(result)))) + ((size_t)(record_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(var_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), rec_type->size);
   } else {
    pointer_t ptr = u_flat_to_data(var_type, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(var_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))));
    frame_set_pointer(da_record_frame(result), record_slot, ptr);
   }

   (ip += ((((2) + 1) / 2)));
  }
  frame_set_pointer(fp, result_slot, pointer_data(result));
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_RECORD_LOAD0: do {

 frame_t record, record_slot, result;
 unsigned flags;
 const struct type *t;
 record = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 record_slot = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 result = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]));
 flags = (!((3) & 1) ? (((const unsigned char *)((ip + 1) + (3) / 2))[0]) : (((const unsigned char *)((ip + 1) + (3) / 2))[1]));

 t = frame_get_type_of_local(fp, record);
 if (t->tag == ((((0 + 2 * 5) + 5) + 4) + 3) && !frame_test_flag(fp, record)) {
  const struct flat_record_definition_entry *ft = &(((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "2043", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->entries[record_slot];
  if ((__builtin_expect((int)(((((((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) < 0 + 2 * 5) || (((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) >= ((0 + 2 * 5) + 5) && ((frame_get_type_of_local(fp, result))->tag) < ((0 + 2 * 5) + 5) + 4) || (((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) >= (0 + 2 * 5) && ((frame_get_type_of_local(fp, result))->tag) < (0 + 2 * 5) + 5) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 0)) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 3) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 4)))), 1))) {
   memcpy_fast((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(result) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(record) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))) + ft->flat_offset, ft->subtype->size);
  } else {
   pointer_t ptr = u_flat_to_data(ft->subtype, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(record) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))) + ft->flat_offset);
   frame_set_pointer(fp, result, ptr);
  }
 } else {
  const struct type *rtype, *etype;
  struct data *data;
  frame_s *fr;
  do { pointer_t p_; if (!(1)) p_ = pointer_locked_read((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(record) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); else p_ = *((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(record) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (data) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "2064"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(record) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), ((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) >= 0 ? &frame_execution_control(fp)->wait[((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) & 1] : ((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(record) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))) , "./ipret-1.inc" ":" "2064"); { thunk_reference(thunk_); frame_set_pointer(fp, result, pointer_thunk(thunk_)); goto record_load_end_0;; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) >= 0 && !(((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) & 2)) { u_pointer_follow_wait(fp, ip); } { if (!(flags & 0x0001)) { ex_ = u_ipret_record_load_create_thunk(fp, ip, record, record_slot, result); if (ex_ == ((void *)(uintptr_t)3)) goto record_load_end_0; } do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);
# 2065 "./ipret-1.inc"
  rtype = ((((void)(zero_()))), &(data)->u_.record)->definition;
  etype = (((__builtin_expect((int)((rtype)->tag == ((((0 + 2 * 5) + 5) + 4) + 2)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "2066", "type_def: invalid type tag %u, expected %u", (rtype)->tag, ((((0 + 2 * 5) + 5) + 4) + 2))), ((void)sizeof(&(((struct record_definition *)(void *)((((char *)(void *)((rtype))) - __builtin_offsetof(struct record_definition, type)))))->type == (rtype)), (((struct record_definition *)(void *)((((char *)(void *)((rtype))) - __builtin_offsetof(struct record_definition, type)))))))->types[record_slot];
  fr = da_record_frame(data);
  if (!frame_test_flag(fr, record_slot)) {
    if ((__builtin_expect((int)(((((((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) < 0 + 2 * 5) || (((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) >= ((0 + 2 * 5) + 5) && ((frame_get_type_of_local(fp, result))->tag) < ((0 + 2 * 5) + 5) + 4) || (((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) >= (0 + 2 * 5) && ((frame_get_type_of_local(fp, result))->tag) < (0 + 2 * 5) + 5) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 0)) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 3) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 4)))), 1))) {
    memcpy_fast((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(result) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fr))) + ((size_t)(record_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), etype->size);
    } else {
    pointer_t ptr = u_flat_to_data(etype, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fr))) + ((size_t)(record_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))));
    frame_set_pointer(fp, result, ptr);
    }
  } else {
   u_pointer_reference_maybe_(fp, result, (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fr))) + ((size_t)(record_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), flags , "./ipret-1.inc" ":" "2076");
  }
 }

record_load_end_0:
 (ip += (1 + (((4) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_OPTION_CREATE_EMPTY_FLAT0: do {

 frame_t slot_r = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 ajla_flat_option_t opt = (ajla_flat_option_t)(!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 ((void)(zero_()));
 __asm__ volatile ("":::"memory");
 *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = opt;
 __asm__ volatile ("":::"memory");
 (ip += (1 + (((2) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_OPTION_CREATE_EMPTY0: do {

 struct data *d;
 frame_t slot_r;

 d = data_init_(((struct data *)(void *)(ptrcomp_verify(((void *)(void *)(mem_align_position((__builtin_offsetof(struct data, u_.option) + sizeof(((struct data *)((void*)0))->u_.option)), (((((uintptr_t)1 << 0) * 2)) >= (1) ? ((((uintptr_t)1 << 0) * 2)) : (1)), &ajla_error , "./ipret-1.inc" ":" "2102")))))), 4);
 slot_r = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 if ((__builtin_expect((int)(d != ((void*)0)), 1))) {
  ((((void)(zero_()))), &(d)->u_.option)->option = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
  ((((void)(zero_()))), &(d)->u_.option)->pointer = pointer_empty();
  frame_set_pointer(fp, slot_r, pointer_data(d));
 } else {
  frame_set_pointer(fp, slot_r, u_pointer_error(ajla_error, fp, ip , "./ipret-1.inc" ":" "2109"));
 }
 (ip += (1 + (((2) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_OPTION_CREATE0: do {

 struct data *d;
 frame_t slot_1, slot_r;
 pointer_t ptr;

 slot_1 = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]));
 if (!frame_variable_is_flat(fp, slot_1)) {
  ptr = frame_get_pointer_reference(fp, slot_1, ((!((3) & 1) ? (((const unsigned char *)((ip + 1) + (3) / 2))[0]) : (((const unsigned char *)((ip + 1) + (3) / 2))[1])) & 0x0002) != 0);
 } else {
  ptr = u_flat_to_data(frame_get_type_of_local(fp, slot_1), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))));
 }

 d = data_init_(((struct data *)(void *)(ptrcomp_verify(((void *)(void *)(mem_align_position((__builtin_offsetof(struct data, u_.option) + sizeof(((struct data *)((void*)0))->u_.option)), (((((uintptr_t)1 << 0) * 2)) >= (1) ? ((((uintptr_t)1 << 0) * 2)) : (1)), &ajla_error , "./ipret-1.inc" ":" "2128")))))), 4);
 slot_r = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 if ((__builtin_expect((int)(d != ((void*)0)), 1))) {
  ((((void)(zero_()))), &(d)->u_.option)->option = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
  ((((void)(zero_()))), &(d)->u_.option)->pointer = ptr;
  frame_set_pointer(fp, slot_r, pointer_data(d));
 } else {
  u_pointer_dereference_(ptr , "./ipret-1.inc" ":" "2135");
  frame_set_pointer(fp, slot_r, u_pointer_error(ajla_error, fp, ip , "./ipret-1.inc" ":" "2136"));
 }
 (ip += (1 + (((4) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_OPTION_LOAD0: do {

 frame_t option, option_idx, result;
 unsigned flags;
 struct data *data;
 pointer_t ptr;

 option = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 option_idx = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 result = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]));
 flags = (!((3) & 1) ? (((const unsigned char *)((ip + 1) + (3) / 2))[0]) : (((const unsigned char *)((ip + 1) + (3) / 2))[1]));

 if ((__builtin_expect((int)(frame_variable_is_flat(fp, option)), 0)))
  goto option_load_mismatch0;

 do { pointer_t p_; if (!(1)) p_ = pointer_locked_read((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(option) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); else p_ = *((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(option) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (data) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "2167"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(option) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), ((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) >= 0 ? &frame_execution_control(fp)->wait[((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) & 1] : ((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(option) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))) , "./ipret-1.inc" ":" "2167"); { thunk_reference(thunk_); frame_set_pointer(fp, result, pointer_thunk(thunk_)); goto option_load_end_0;; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) >= 0 && !(((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) & 2)) { u_pointer_follow_wait(fp, ip); } { if (!(flags & 0x0001)) { ex_ = u_ipret_option_load_create_thunk(fp, ip, option, option_idx, result); if (ex_ == ((void *)(uintptr_t)3)) goto option_load_end_0; } do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);
# 2169 "./ipret-1.inc"
 if ((__builtin_expect((int)(((((void)(zero_()))), &(data)->u_.option)->option != option_idx), 0))) {
option_load_mismatch0:
  ptr = u_pointer_error(error_ajla_aux_(1, 10, 0 , "./ipret-1.inc" ":" "2171"), fp, ip , "./ipret-1.inc" ":" "2171");
  frame_set_pointer(fp, result, ptr);
 } else {
  u_pointer_reference_maybe_(fp, result, &((((void)(zero_()))), &(data)->u_.option)->pointer, flags , "./ipret-1.inc" ":" "2174");
 }

option_load_end_0:
 (ip += (1 + (((4) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


{ frame_t slot_1; ajla_option_t option;




label_OPCODE_OPTION_TEST_FLAT0: do {

 slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));

 if (!frame_test_flag(fp, slot_1)) {
  __asm__ volatile ("":::"memory");
  option = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
  __asm__ volatile ("":::"memory");
  goto option_test_store_result_0;
 }
 goto option_test_0;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_OPTION_TEST0: do {

 frame_t slot_r;
 pointer_t ptr;
 struct data *data;

 slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
option_test_0:
 ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
 if ((__builtin_expect((int)(pointer_is_thunk(ptr)), 0))) {
  void *ex;
  ((void)(zero_()));
  ex = u_thunk_option_test(fp, ip, slot_1, (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])), (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1])));
  if (ex == ((void *)(uintptr_t)3)) {
   (ip += (1 + (((3) + 1) / 2)));
   break;
  } else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) {
   do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
  }
  break;
 }
 data = pointer_get_data_(ptr , "./ipret-1.inc" ":" "2223");
 option = ((((void)(zero_()))), &(data)->u_.option)->option;
option_test_store_result_0:
 slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]));
 __asm__ volatile ("":::"memory");
 ((void)(zero_()));
 *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = option == (ajla_option_t)(!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 __asm__ volatile ("":::"memory");
 (ip += (1 + (((3) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_OPTION_ORD_FLAT0: do {

 slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));

 if (!frame_test_flag(fp, slot_1)) {
  __asm__ volatile ("":::"memory");
  option = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
  __asm__ volatile ("":::"memory");
  goto option_ord_store_result_0;
 }
 goto option_ord_0;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_OPTION_ORD0: do {

 frame_t slot_r;
 pointer_t ptr;
 struct data *data;

 slot_1 = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
option_ord_0:
 ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
 if ((__builtin_expect((int)(pointer_is_thunk(ptr)), 0))) {
  void *ex;
  ((void)(zero_()));
  ex = u_thunk_option_ord(fp, ip, slot_1, (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])));
  if (ex == ((void *)(uintptr_t)3)) {
   (ip += (1 + (((2) + 1) / 2)));
   break;
  } else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) {
   do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
  }
  break;
 }
 data = pointer_get_data_(ptr , "./ipret-1.inc" ":" "2270");
 option = ((((void)(zero_()))), &(data)->u_.option)->option;
option_ord_store_result_0:
 slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 __asm__ volatile ("":::"memory");
 ((void)(zero_()));
 *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = option;
 __asm__ volatile ("":::"memory");
 (ip += (1 + (((2) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

}


label_OPCODE_ARRAY_CREATE0: do {

 frame_t result_slot;
 size_t n_entries;
 struct data *total;

 result_slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 n_entries = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 (ip += (1 + (((2) + 1) / 2)));

 ((void)(zero_()));

 total = ((void*)0);
 while (1) {
  size_t n, i;
  struct data *a;
  const struct type *type = frame_get_type_of_local(fp, (!((0) & 1) ? (((const unsigned char *)((ip) + (0) / 2))[0]) : (((const unsigned char *)((ip) + (0) / 2))[1])));
  _Bool flat = frame_variable_is_flat(fp, (!((0) & 1) ? (((const unsigned char *)((ip) + (0) / 2))[0]) : (((const unsigned char *)((ip) + (0) / 2))[1])));
  for (n = 1; n < n_entries; n++) {
   if (frame_variable_is_flat(fp, (!((n * 2) & 1) ? (((const unsigned char *)((ip) + (n * 2) / 2))[0]) : (((const unsigned char *)((ip) + (n * 2) / 2))[1]))) != flat)
    break;
   if ((__builtin_expect((int)((int64_t)(n + 1) < (zero_())), 0)))
    break;
  }
  do {
   if (flat)
    a = u_data_alloc_array_flat_mayfail(type, n, n, 0, &ajla_error , "./ipret-1.inc" ":" "2311");
   else
    a = u_data_alloc_array_pointers_mayfail(n, n, &ajla_error , "./ipret-1.inc" ":" "2313");
  } while ((__builtin_expect((int)(!a), 0)) && (n >>= 1));
  if ((__builtin_expect((int)(!a), 0))) {
   if (total)
    data_dereference(total);
   goto array_create_error_0;
  }
  n_entries -= n;
  if (flat) {
   unsigned char *flat_ptr = da_array_flat(a);
   for (i = 0; i < n; i++) {
    frame_t var_slot = (!((0) & 1) ? (((const unsigned char *)((ip) + (0) / 2))[0]) : (((const unsigned char *)((ip) + (0) / 2))[1]));
    memcpy_fast(flat_ptr, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(var_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), type->size);
    flat_ptr += type->size;
    (ip += ((((2) + 1) / 2)));
   }
  } else {
   for (i = 0; i < n; i++) {
    frame_t var_slot = (!((0) & 1) ? (((const unsigned char *)((ip) + (0) / 2))[0]) : (((const unsigned char *)((ip) + (0) / 2))[1]));
    pointer_t ptr = frame_get_pointer_reference(fp, var_slot, ((!((1) & 1) ? (((const unsigned char *)((ip) + (1) / 2))[0]) : (((const unsigned char *)((ip) + (1) / 2))[1])) & 0x0002) != 0);
    ((((void)(zero_()))), &(a)->u_.array_pointers)->pointer[i] = ptr;
    (ip += ((((2) + 1) / 2)));
   }
  }
  if ((__builtin_expect((int)(!total), 1))) {
   total = a;
  } else {
   total = u_array_join(total, a, &ajla_error);
   if ((__builtin_expect((int)(!total), 0))) {
array_create_error_0:
    ip = free_parameters_0(fp, ip, n_entries);
    frame_set_pointer(fp, result_slot, u_pointer_error(ajla_error, fp, ip , "./ipret-1.inc" ":" "2344"));
    break;
   }
  }
  if ((__builtin_expect((int)(!n_entries), 1))) {
   frame_set_pointer(fp, result_slot, pointer_data(total));
   break;
  }
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_CREATE_EMPTY_FLAT0: do {

 frame_t result_slot;
 struct data *a;
 const struct type *type = da_type((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function, (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1])));
 ((void)(zero_()));

 a = u_data_alloc_array_flat_mayfail(type, 0, 0, 0, &ajla_error , "./ipret-1.inc" ":" "2363");
 result_slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 frame_set_pointer(fp, result_slot, (__builtin_expect((int)(a != ((void*)0)), 1)) ? pointer_data(a) : u_pointer_error(ajla_error, fp, ip , "./ipret-1.inc" ":" "2365"));
 (ip += (1 + (((2) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_CREATE_EMPTY0: do {

 frame_t result_slot;
 struct data *a;

 a = u_data_alloc_array_pointers_mayfail(0, 0, &ajla_error , "./ipret-1.inc" ":" "2375");
 result_slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 frame_set_pointer(fp, result_slot, (__builtin_expect((int)(a != ((void*)0)), 1)) ? pointer_data(a) : u_pointer_error(ajla_error, fp, ip , "./ipret-1.inc" ":" "2377"));
 (ip += (1 + (((1) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_FILL0: do {

 frame_t content_slot, length_slot, result_slot;
 unsigned char content_flag;
 array_index_t length;
 pointer_t result_ptr;
 void *ex;

 content_slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 content_flag = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 length_slot = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]));
 result_slot = (!((3) & 1) ? (((const unsigned char *)((ip + 1) + (3) / 2))[0]) : (((const unsigned char *)((ip + 1) + (3) / 2))[1]));

 ex = u_ipret_get_index(fp, ip, fp, length_slot, ((void*)0), &length, &result_ptr , "./ipret-1.inc" ":" "2395");
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0))) {
  if (ex == ((void *)(uintptr_t)2)) {
   if (content_flag & 0x0002)
    frame_free_and_clear(fp, content_slot);
   goto array_fill_error_0;
  }
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
 }

 if (!frame_variable_is_flat(fp, content_slot)) {
  pointer_t ptr = frame_get_pointer_reference(fp, content_slot, (content_flag & 0x0002) != 0);
  if ((__builtin_expect((int)((content_flag & 0x0004) != 0), 0))) {
   result_ptr = u_array_create_sparse(length, ptr);
  } else {
   result_ptr = u_array_create(length, ((void*)0), ((void*)0), ptr);
  }
 } else {
  const struct type *type = frame_get_type_of_local(fp, content_slot);
  __asm__ volatile ("":::"memory");
  if ((__builtin_expect((int)((content_flag & 0x0004) != 0), 0)) && (__builtin_expect((int)(index_ge_int_(length, 1 , "./ipret-1.inc" ":" "2415")), 1))) {
   pointer_t ptr = u_flat_to_data(type, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(content_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))));
   result_ptr = u_array_create_sparse(length, ptr);
  } else {
   if (((((((void)(zero_())), ((frame_get_type_of_local(fp, result_slot))->tag) < 0 + 2 * 5) || (((void)(zero_())), ((frame_get_type_of_local(fp, result_slot))->tag) >= ((0 + 2 * 5) + 5) && ((frame_get_type_of_local(fp, result_slot))->tag) < ((0 + 2 * 5) + 5) + 4) || (((void)(zero_())), ((frame_get_type_of_local(fp, result_slot))->tag) >= (0 + 2 * 5) && ((frame_get_type_of_local(fp, result_slot))->tag) < (0 + 2 * 5) + 5) || ((frame_get_type_of_local(fp, result_slot))->tag) == ((((0 + 2 * 5) + 5) + 4) + 0)) || ((frame_get_type_of_local(fp, result_slot))->tag) == ((((0 + 2 * 5) + 5) + 4) + 3) || ((frame_get_type_of_local(fp, result_slot))->tag) == ((((0 + 2 * 5) + 5) + 4) + 4)))) {
    unsigned char *result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(result_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))));
    int64_t l = index_to_int_(length , "./ipret-1.inc" ":" "2421");
    index_free_(&length , "./ipret-1.inc" ":" "2422");
    while (l--) {
     result = mempcpy(result, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(content_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), type->size);
    }
    goto array_exit_0;
   } else {
    result_ptr = u_array_create(length, type, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(content_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), pointer_empty());
   }
  }
  __asm__ volatile ("":::"memory");
 }

array_fill_error_0:
 frame_set_pointer(fp, result_slot, result_ptr);

array_exit_0:
 (ip += (1 + (((4) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_STRING0: do {

 frame_t result_slot, length;
 pointer_t result_ptr;

 result_slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 length = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 (ip += (1 + (((2) + 1) / 2)));

 if ((__builtin_expect((int)((int64_t)length < (int64_t)(zero_())), 0)) ||
     (__builtin_expect((int)((frame_t)(int64_t)length != length), 0))) {
  result_ptr = u_pointer_error(error_ajla_aux_(2, 3, 0 , "./ipret-1.inc" ":" "2453"), fp, ip , "./ipret-1.inc" ":" "2453");
 } else {
  result_ptr = u_array_string(length, type_get_fixed(0, 1), ((unsigned char *)(void *)(ip)));
 }
 frame_set_pointer(fp, result_slot, result_ptr);

 (ip += ((length + 1) >> 1));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_UNICODE0: do {

 frame_t result_slot, length;
 pointer_t result_ptr;

 result_slot = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 length = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 (ip += (1 + (((2) + 1) / 2)));

 if ((__builtin_expect((int)((int64_t)length < (int64_t)(zero_())), 0)) ||
     (__builtin_expect((int)((frame_t)(int64_t)length != length), 0))) {
  result_ptr = u_pointer_error(error_ajla_aux_(2, 3, 0 , "./ipret-1.inc" ":" "2474"), fp, ip , "./ipret-1.inc" ":" "2474");
 } else {
  result_ptr = u_array_string(length, type_get_int(2), ((unsigned char *)(void *)(ip)));
 }
 frame_set_pointer(fp, result_slot, result_ptr);

 (ip += (length * 2));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_LOAD0: do {

 frame_t array, idx, result;
 unsigned flags;
 const struct type *t, *t_elem;
 void *ex;
 array_index_t array_index;
 pointer_t ptr;
 unsigned char *flat;

 array = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 idx = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 result = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]));
 flags = (!((3) & 1) ? (((const unsigned char *)((ip + 1) + (3) / 2))[0]) : (((const unsigned char *)((ip + 1) + (3) / 2))[1]));

 ex = u_ipret_get_index(fp, ip, fp, idx, ((void*)0), &array_index, &ptr , "./ipret-1.inc" ":" "2499");
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0))) {
  if (ex == ((void *)(uintptr_t)2))
   goto array_load_set_ptr_0;
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
 }

 t = frame_get_type_of_local(fp, array);
 if (t->tag == ((((0 + 2 * 5) + 5) + 4) + 4) && !frame_test_flag(fp, array)) {
  const struct flat_array_definition *def = (((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 4)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "2508", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 4))), ((void)sizeof(&(((struct flat_array_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_array_definition, type)))))->type == (t)), (((struct flat_array_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_array_definition, type)))))));
  if ((__builtin_expect((int)(index_ge_int_(array_index, def->n_elements , "./ipret-1.inc" ":" "2509")), 0))) {
   if ((__builtin_expect((int)((flags & 0x0004) != 0), 0)))
    internal("./ipret-1.inc" ":" "2511", "array_load: flat array index out of range");
   index_free_(&array_index , "./ipret-1.inc" ":" "2512");
   ptr = u_pointer_error(error_ajla_aux_(1, 9, 0 , "./ipret-1.inc" ":" "2513"), fp, ip , "./ipret-1.inc" ":" "2513");
   goto array_load_set_ptr_0;
  }
  t_elem = def->base;
  flat = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(array) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))) + t_elem->size * index_to_int_(array_index , "./ipret-1.inc" ":" "2517");
  index_free_(&array_index , "./ipret-1.inc" ":" "2518");
  goto array_load_set_flat_0;
 } else {
  pointer_t *array_ptr = (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(array) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
  pointer_t *pptr;
  struct data *data;

array_restart_pointer_follow_0:
  do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(array_ptr); else p_ = *(array_ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (data) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "2538"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(array_ptr, ((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) >= 0 ? &frame_execution_control(fp)->wait[((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) & 1] : ((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(array_ptr) , "./ipret-1.inc" ":" "2538"); { index_free_(&array_index , "./ipret-1.inc" ":" "2534"); thunk_reference(thunk_); ptr = pointer_thunk(thunk_); goto array_load_set_ptr_0;; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) >= 0 && !(((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) & 2)) { u_pointer_follow_wait(fp, ip); } { index_free_(&array_index , "./ipret-1.inc" ":" "2527"); if (!(flags & 0x0001)) { ex_ = u_ipret_array_load_create_thunk(fp, ip, array, idx, result); if (ex_ == ((void *)(uintptr_t)3)) goto array_load_end_0; } do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);
# 2540 "./ipret-1.inc"
  if ((__builtin_expect((int)((((void)(zero_())), (refcount_tag_get((const refcount_t *)&(data)->refcount_))) == 10), 0))) {
   array_index_t len_first;

   if (array_ptr == (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(array) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))) {
    if (!frame_test_and_set_flag(fp, array))
     data_reference(data);
    if (u_array_incomplete_collapse(array_ptr))
     goto array_restart_pointer_follow_0;
   }

   len_first = u_array_len(pointer_get_data_(((((void)(zero_()))), &(data)->u_.array_incomplete)->first , "./ipret-1.inc" ":" "2550"));
   if (!index_ge_index_(array_index, len_first , "./ipret-1.inc" ":" "2551")) {
    index_free_(&len_first , "./ipret-1.inc" ":" "2552");
    data = pointer_get_data_(((((void)(zero_()))), &(data)->u_.array_incomplete)->first , "./ipret-1.inc" ":" "2553");
   } else {
    index_sub_(&array_index, len_first , "./ipret-1.inc" ":" "2555");
    index_free_(&len_first , "./ipret-1.inc" ":" "2556");
    array_ptr = &((((void)(zero_()))), &(data)->u_.array_incomplete)->next;
    goto array_restart_pointer_follow_0;
   }
  }

  if ((__builtin_expect((int)(!u_array_read(data, array_index, &pptr, &flat, &t_elem, ((void*)0))), 0))) {
   if ((__builtin_expect((int)((flags & 0x0004) != 0), 0)))
    internal("./ipret-1.inc" ":" "2564", "array_load: array index out of range");
   ptr = u_pointer_error(error_ajla_aux_(1, 9, 0 , "./ipret-1.inc" ":" "2565"), fp, ip , "./ipret-1.inc" ":" "2565");
   goto array_load_set_ptr_0;
  }
  if (pptr) {
   u_pointer_reference_maybe_(fp, result, pptr, flags , "./ipret-1.inc" ":" "2569");
   goto array_load_end_0;
  } else {
array_load_set_flat_0:
    if ((__builtin_expect((int)(((((((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) < 0 + 2 * 5) || (((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) >= ((0 + 2 * 5) + 5) && ((frame_get_type_of_local(fp, result))->tag) < ((0 + 2 * 5) + 5) + 4) || (((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) >= (0 + 2 * 5) && ((frame_get_type_of_local(fp, result))->tag) < (0 + 2 * 5) + 5) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 0)) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 3) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 4)))), 1))) {
    memcpy_fast((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(result) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), flat, t_elem->size);
    goto array_load_end_0;
    } else {
    ptr = u_flat_to_data(t_elem, flat);
    }
  }
 }

array_load_set_ptr_0:
 frame_set_pointer(fp, result, ptr);

array_load_end_0:
 (ip += (1 + (((4) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_LEN0: do {

 frame_t slot_a, slot_r;
 unsigned flags;
 void *ex;

 slot_a = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 slot_r = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 flags = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]));

 ex = u_ipret_array_len(fp, ip, slot_r, slot_a, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + (((3) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_LEN_GREATER_THAN0: do {

 frame_t slot_a, slot_l, slot_r;
 unsigned flags;
 void *ex;

 slot_a = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 slot_l = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]));
 flags = (!((3) & 1) ? (((const unsigned char *)((ip + 1) + (3) / 2))[0]) : (((const unsigned char *)((ip + 1) + (3) / 2))[1]));

 ex = u_ipret_array_len_greater_than(fp, ip, slot_r, slot_a, slot_l, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + (((4) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_SUB0: do {

 frame_t slot_a, slot_start, slot_end, slot_r;
 unsigned flags;
 void *ex;

 slot_a = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 slot_start = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 slot_end = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]));
 slot_r = (!((3) & 1) ? (((const unsigned char *)((ip + 1) + (3) / 2))[0]) : (((const unsigned char *)((ip + 1) + (3) / 2))[1]));
 flags = (!((4) & 1) ? (((const unsigned char *)((ip + 1) + (4) / 2))[0]) : (((const unsigned char *)((ip + 1) + (4) / 2))[1]));

 ex = u_ipret_array_sub(fp, ip, slot_r, slot_a, slot_start, slot_end, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + (((5) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_SKIP0: do {

 frame_t slot_a, slot_start, slot_r;
 unsigned flags;
 void *ex;

 slot_a = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 slot_start = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 slot_r = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]));
 flags = (!((3) & 1) ? (((const unsigned char *)((ip + 1) + (3) / 2))[0]) : (((const unsigned char *)((ip + 1) + (3) / 2))[1]));

 ex = u_ipret_array_skip(fp, ip, slot_r, slot_a, slot_start, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + (((4) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_APPEND0: do {

 frame_t slot_r, slot_1, slot_2;
 unsigned flags;
 void *ex;

 slot_r = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 flags = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 slot_1 = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]));
 slot_2 = (!((3) & 1) ? (((const unsigned char *)((ip + 1) + (3) / 2))[0]) : (((const unsigned char *)((ip + 1) + (3) / 2))[1]));

 ex = u_ipret_array_append(fp, ip, slot_r, slot_1, slot_2, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + (((4) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_APPEND_ONE_FLAT0: do {

 frame_t slot_r, slot_1, slot_2;
 unsigned flags;
 void *ex;

 slot_r = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 flags = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 slot_1 = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]));
 slot_2 = (!((3) & 1) ? (((const unsigned char *)((ip + 1) + (3) / 2))[0]) : (((const unsigned char *)((ip + 1) + (3) / 2))[1]));

 ex = u_ipret_array_append_one_flat(fp, ip, slot_r, slot_1, slot_2, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + (((4) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_APPEND_ONE0: do {

 frame_t slot_r, slot_1, slot_2;
 unsigned flags;
 void *ex;

 slot_r = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 flags = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 slot_1 = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]));
 slot_2 = (!((3) & 1) ? (((const unsigned char *)((ip + 1) + (3) / 2))[0]) : (((const unsigned char *)((ip + 1) + (3) / 2))[1]));

 ex = u_ipret_array_append_one(fp, ip, slot_r, slot_1, slot_2, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + (((4) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_FLATTEN0: do {

 frame_t slot_r, slot_1;
 unsigned flags;
 void *ex;

 slot_r = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 flags = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 slot_1 = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]));

 ex = u_ipret_array_flatten(fp, ip, slot_r, slot_1, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + (((3) + 1) / 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;



label_OPCODE_IO0: do {

 unsigned char io_code, n_outputs, n_inputs, n_params;
 void *ex;

 io_code = (!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]));
 n_outputs = (!((1) & 1) ? (((const unsigned char *)((ip + 1) + (1) / 2))[0]) : (((const unsigned char *)((ip + 1) + (1) / 2))[1]));
 n_inputs = (!((2) & 1) ? (((const unsigned char *)((ip + 1) + (2) / 2))[0]) : (((const unsigned char *)((ip + 1) + (2) / 2))[1]));
 n_params = (!((3) & 1) ? (((const unsigned char *)((ip + 1) + (3) / 2))[0]) : (((const unsigned char *)((ip + 1) + (3) / 2))[1]));

 ex = u_ipret_io(fp, ip, io_code, n_outputs, n_inputs, n_params);
 if (ex != ((void *)(uintptr_t)3)) {
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
 } else {
  (ip += (3 + 2 * (n_outputs + n_inputs + n_params)));
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;



label_OPCODE_INTERNAL_FUNCTION0: do {

 void *ex = u_function_call_internal(fp, ip);
 if (ex != ((void *)(uintptr_t)1)) {
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;



label_OPCODE_UNREACHABLE0: do {

 internal("./ipret-1.inc" ":" "2777", "unreachable code");

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;



label_OPCODE_EXIT_THREAD0: do {

 struct execution_control *ex = frame_execution_control(fp);
 pointer_t *var_ptr = (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)((!((0) & 1) ? (((const unsigned char *)((ip + 1) + (0) / 2))[0]) : (((const unsigned char *)((ip + 1) + (0) / 2))[1]))) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
 struct data __attribute__((__unused__)) *data;

 do { pointer_t p_; if (!(1)) p_ = pointer_locked_read(var_ptr); else p_ = *(var_ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (data) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "2793"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(var_ptr, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(var_ptr) , "./ipret-1.inc" ":" "2793"); { ((__builtin_expect((int)(thunk_tag_(thunk_, "./ipret-1.inc" ":" "2791") == 25), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "2791", "exit_thread: invalid thunk tag %u", thunk_tag_(thunk_, "./ipret-1.inc" ":" "2791"))); goto exit_ipret_thunk;; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);





exit_ipret_thunk:
 ((__builtin_expect((int)(ex->thunk == ((void*)0)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "2796", "exit_thread: non-NULL thunk %p", ex->thunk));
 ex->current_frame = fp;
 ex->current_ip = frame_ip(fp, ip);
 u_execution_control_terminate(ex, *var_ptr);
 goto exit_ipret;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 49 "./ipret.inc" 2






# 1 "./ipret-1.inc" 1
# 317 "./ipret-1.inc"
 label_FIXED_binary_add_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_add_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_subtract_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_subtract_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_multiply_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_multiply_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_divide_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_divide_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_udivide_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_udivide_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_modulo_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_modulo_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_umodulo_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_umodulo_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_power_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_power_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_and_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_and_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_or_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_or_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_xor_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_xor_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shl_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shl_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shr_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shr_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ushr_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ushr_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_rol_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_rol_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ror_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ror_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_bts_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bts_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btr_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btr_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btc_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btc_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_equal_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_equal_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_not_equal_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_not_equal_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_less_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_less_equal_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_equal_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_uless_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_uless_equal_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_equal_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_bt_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bt_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_not_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_not_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_neg_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_neg_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_inc_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_inc_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_dec_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_dec_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bswap_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bswap_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_brev_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_brev_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsf_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsf_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsr_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_popcnt_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_to_int_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int8_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_uto_int_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { uint8_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((uint8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)((uint8_t)r != val1), 0)) || (__builtin_expect((int)(r < 0), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 1)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_from_int_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int64_t val1; int8_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int8_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_ufrom_int_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int64_t val1; uint8_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (uint8_t)val1; if ((__builtin_expect((int)((int64_t)r != val1), 0)) || (__builtin_expect((int)(val1 < 0), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_move_int8_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_copy_int8_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_int8_t_1: do { frame_t slot; uint8_t *val; ip_t sz; slot = ((uintptr_t)(ip + 1)[0]); ((void)(zero_())); val = (((uint8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int8_t(val, ip + 1 + (1), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (1))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_add_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_add_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_subtract_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_subtract_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_multiply_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_multiply_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_divide_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_divide_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_udivide_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_udivide_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_modulo_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_modulo_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_umodulo_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_umodulo_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_power_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_power_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_and_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_and_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_or_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_or_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_xor_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_xor_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shl_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shl_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shr_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shr_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ushr_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ushr_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_rol_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_rol_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ror_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ror_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_bts_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bts_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btr_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btr_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btc_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btc_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_equal_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_equal_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_not_equal_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_not_equal_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_less_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_less_equal_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_equal_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_uless_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_uless_equal_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_equal_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_bt_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bt_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_not_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_not_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_neg_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_neg_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_inc_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_inc_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_dec_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_dec_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bswap_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bswap_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_brev_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_brev_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsf_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsf_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsr_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_popcnt_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_to_int_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int16_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_uto_int_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { uint16_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((uint16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)((uint16_t)r != val1), 0)) || (__builtin_expect((int)(r < 0), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 1)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_from_int_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int64_t val1; int16_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int16_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_ufrom_int_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int64_t val1; uint16_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (uint16_t)val1; if ((__builtin_expect((int)((int64_t)r != val1), 0)) || (__builtin_expect((int)(val1 < 0), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_move_int16_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_copy_int16_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_int16_t_1: do { frame_t slot; uint16_t *val; ip_t sz; slot = ((uintptr_t)(ip + 1)[0]); ((void)(zero_())); val = (((uint16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int16_t(val, ip + 1 + (1), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (1))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_add_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_add_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_subtract_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_subtract_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_multiply_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_multiply_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_divide_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_divide_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_udivide_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_udivide_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_modulo_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_modulo_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_umodulo_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_umodulo_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_power_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_power_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_and_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_and_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_or_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_or_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_xor_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_xor_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shl_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shl_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shr_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shr_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ushr_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ushr_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_rol_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_rol_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ror_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ror_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_bts_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bts_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btr_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btr_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btc_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btc_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_equal_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_equal_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_not_equal_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_not_equal_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_less_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_less_equal_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_equal_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_uless_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_uless_equal_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_equal_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_bt_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bt_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_not_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_not_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_neg_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_neg_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_inc_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_inc_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_dec_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_dec_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bswap_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bswap_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_brev_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_brev_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsf_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsf_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsr_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_popcnt_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_to_int_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int32_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_uto_int_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { uint32_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((uint32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)((uint32_t)r != val1), 0)) || (__builtin_expect((int)(r < 0), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 1)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_from_int_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int64_t val1; int32_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int32_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_ufrom_int_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int64_t val1; uint32_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (uint32_t)val1; if ((__builtin_expect((int)((int64_t)r != val1), 0)) || (__builtin_expect((int)(val1 < 0), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_move_int32_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_copy_int32_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_int32_t_1: do { frame_t slot; uint32_t *val; ip_t sz; slot = ((uintptr_t)(ip + 1)[0]); ((void)(zero_())); val = (((uint32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int32_t(val, ip + 1 + (1), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (1))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_add_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_add_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_subtract_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_subtract_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_multiply_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_multiply_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_divide_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_divide_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_udivide_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_udivide_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_modulo_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_modulo_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_umodulo_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_umodulo_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_power_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_power_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_and_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_and_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_or_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_or_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_xor_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_xor_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shl_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shl_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shr_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shr_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ushr_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ushr_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_rol_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_rol_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ror_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ror_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_bts_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bts_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btr_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btr_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btc_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btc_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_equal_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_equal_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_not_equal_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_not_equal_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_less_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_less_equal_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_equal_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_uless_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_uless_equal_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_equal_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_bt_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bt_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_not_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_not_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_neg_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_neg_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_inc_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_inc_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_dec_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_dec_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bswap_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bswap_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_brev_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_brev_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsf_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsf_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsr_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_popcnt_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_to_int_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int64_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_uto_int_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { uint64_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((uint64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)((uint64_t)r != val1), 0)) || (__builtin_expect((int)(r < 0), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 1)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_from_int_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int64_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_ufrom_int_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int64_t val1; uint64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (uint64_t)val1; if ((__builtin_expect((int)((int64_t)r != val1), 0)) || (__builtin_expect((int)(val1 < 0), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_move_int64_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_copy_int64_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_int64_t_1: do { frame_t slot; uint64_t *val; ip_t sz; slot = ((uintptr_t)(ip + 1)[0]); ((void)(zero_())); val = (((uint64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int64_t(val, ip + 1 + (1), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (1))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_add_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_add_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_subtract_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_subtract_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_multiply_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_multiply_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_divide_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_divide_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_udivide_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_udivide_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_modulo_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_modulo_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_umodulo_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_umodulo_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_power_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_power_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_and_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_and_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_or_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_or_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_xor_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_xor_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shl_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shl_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shr_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shr_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ushr_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ushr_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_rol_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_rol_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ror_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ror_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_bts_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bts_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btr_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btr_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btc_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btc_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_equal_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_equal_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_not_equal_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_not_equal_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_less_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_less_equal_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_equal_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_uless_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_uless_equal_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_equal_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_bt_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bt_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_not_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_not_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_neg_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_neg_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_inc_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_inc_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_dec_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_dec_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bswap_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bswap_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_brev_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_brev_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsf_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsf_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsr_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_popcnt_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_to_int_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int128_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_uto_int_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { uint128_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((uint128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)((uint128_t)r != val1), 0)) || (__builtin_expect((int)(r < 0), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 1)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_from_int_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int64_t val1; int128_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int128_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_ufrom_int_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int64_t val1; uint128_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (uint128_t)val1; if ((__builtin_expect((int)((int64_t)r != val1), 0)) || (__builtin_expect((int)(val1 < 0), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_move_int128_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_copy_int128_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_int128_t_1: do { frame_t slot; uint128_t *val; ip_t sz; slot = ((uintptr_t)(ip + 1)[0]); ((void)(zero_())); val = (((uint128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int128_t(val, ip + 1 + (1), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (1))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


label_fixed_ldc16_int32_t_1: do { frame_t slot; uint32_t *val; ip_t sz; slot = ((uintptr_t)(ip + 1)[0]); ((void)(zero_())); val = (((uint32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int32_t(val, ip + 1 + (1), 1); __asm__ volatile ("":::"memory"); (ip += (1 + (1))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_fixed_ldc16_int64_t_1: do { frame_t slot; uint64_t *val; ip_t sz; slot = ((uintptr_t)(ip + 1)[0]); ((void)(zero_())); val = (((uint64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int64_t(val, ip + 1 + (1), 1); __asm__ volatile ("":::"memory"); (ip += (1 + (1))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_fixed_ldc16_int128_t_1: do { frame_t slot; uint128_t *val; ip_t sz; slot = ((uintptr_t)(ip + 1)[0]); ((void)(zero_())); val = (((uint128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int128_t(val, ip + 1 + (1), 1); __asm__ volatile ("":::"memory"); (ip += (1 + (1))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 420 "./ipret-1.inc"
 label_REAL_binary_add_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_subtract_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_multiply_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_divide_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_modulo_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_modulo_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_power_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_power_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_ldexp_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_ldexp_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_atan2_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_atan2_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_equal_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_not_equal_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_equal_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_neg_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sqrt_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cbrt_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cbrt_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sin_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sin_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cos_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cos_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tan_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tan_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asin_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asin_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acos_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acos_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atan_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atan_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sinh_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sinh_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cosh_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cosh_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tanh_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tanh_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asinh_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asinh_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acosh_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acosh_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atanh_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atanh_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp2_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp2_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp10_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp10_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log2_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log2_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log10_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log10_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_round_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_round_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_ceil_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_ceil_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_floor_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_floor_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_trunc_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_trunc_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_fract_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_fract_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_mantissa_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_mantissa_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exponent_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exponent_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_next_number_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_next_number_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_prev_number_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_prev_number_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_to_int_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_real16_t((((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_from_int_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_real16_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_is_exception_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_move_real16_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_copy_real16_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_real16_t_1: do { frame_t slot; real16_t *val; ip_t sz; slot = ((uintptr_t)(ip + 1)[0]); ((void)(zero_())); val = (((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_real16_t(val, ip + 1 + (1), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (1))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_add_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_subtract_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_multiply_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_divide_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_modulo_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_modulo_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_power_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_power_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_ldexp_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_ldexp_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_atan2_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_atan2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_equal_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_not_equal_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_equal_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_neg_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sqrt_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cbrt_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cbrt_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sin_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sin_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cos_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cos_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tan_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tan_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asin_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asin_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acos_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acos_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atan_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atan_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sinh_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sinh_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cosh_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cosh_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tanh_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tanh_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asinh_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asinh_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acosh_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acosh_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atanh_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atanh_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp2_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp2_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp10_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp10_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log2_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log2_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log10_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log10_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_round_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_round_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_ceil_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_ceil_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_floor_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_floor_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_trunc_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_trunc_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_fract_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_fract_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_mantissa_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_mantissa_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exponent_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exponent_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_next_number_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_next_number_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_prev_number_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_prev_number_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_to_int_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_real32_t((((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_from_int_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_real32_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_is_exception_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_move_real32_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_copy_real32_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_real32_t_1: do { frame_t slot; real32_t *val; ip_t sz; slot = ((uintptr_t)(ip + 1)[0]); ((void)(zero_())); val = (((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_real32_t(val, ip + 1 + (1), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (1))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_add_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_subtract_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_multiply_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_divide_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_modulo_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_modulo_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_power_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_power_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_ldexp_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_ldexp_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_atan2_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_atan2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_equal_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_not_equal_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_equal_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_neg_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sqrt_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cbrt_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cbrt_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sin_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sin_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cos_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cos_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tan_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tan_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asin_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asin_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acos_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acos_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atan_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atan_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sinh_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sinh_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cosh_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cosh_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tanh_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tanh_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asinh_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asinh_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acosh_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acosh_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atanh_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atanh_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp2_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp2_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp10_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp10_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log2_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log2_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log10_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log10_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_round_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_round_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_ceil_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_ceil_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_floor_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_floor_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_trunc_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_trunc_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_fract_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_fract_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_mantissa_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_mantissa_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exponent_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exponent_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_next_number_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_next_number_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_prev_number_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_prev_number_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_to_int_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_real64_t((((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_from_int_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_real64_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_is_exception_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_move_real64_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_copy_real64_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_real64_t_1: do { frame_t slot; real64_t *val; ip_t sz; slot = ((uintptr_t)(ip + 1)[0]); ((void)(zero_())); val = (((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_real64_t(val, ip + 1 + (1), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (1))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_add_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_subtract_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_multiply_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_divide_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_modulo_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_modulo_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_power_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_power_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_ldexp_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_ldexp_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_atan2_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_atan2_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_equal_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_not_equal_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_equal_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_neg_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sqrt_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cbrt_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cbrt_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sin_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sin_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cos_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cos_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tan_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tan_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asin_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asin_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acos_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acos_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atan_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atan_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sinh_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sinh_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cosh_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cosh_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tanh_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tanh_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asinh_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asinh_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acosh_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acosh_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atanh_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atanh_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp2_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp2_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp10_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp10_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log2_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log2_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log10_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log10_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_round_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_round_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_ceil_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_ceil_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_floor_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_floor_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_trunc_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_trunc_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_fract_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_fract_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_mantissa_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_mantissa_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exponent_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exponent_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_next_number_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_next_number_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_prev_number_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_prev_number_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_to_int_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_real80_t((((real80_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_from_int_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_real80_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real80_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_is_exception_real80_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_move_real80_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((real80_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real80_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_copy_real80_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((real80_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real80_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_real80_t_1: do { frame_t slot; real80_t *val; ip_t sz; slot = ((uintptr_t)(ip + 1)[0]); ((void)(zero_())); val = (((real80_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_real80_t(val, ip + 1 + (1), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (1))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


escape_fixed_binary_thunk_1: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_fixed_operator(fp, ip, ((uintptr_t)(ip + 1)[0]), ((uintptr_t)(ip + 1)[1]), ((uintptr_t)(ip + 1)[2]), ((uintptr_t)(ip + 1)[3])); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + (4))); else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 434 "./ipret-1.inc"
escape_fixed_unary_thunk_1: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_fixed_operator(fp, ip, ((uintptr_t)(ip + 1)[0]), ((frame_t)-1), ((uintptr_t)(ip + 1)[1]), ((uintptr_t)(ip + 1)[2])); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + (3))); else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 445 "./ipret-1.inc"
escape_convert_thunk_1: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_convert(fp, ip, ((uintptr_t)(ip + 1)[0]), ((uintptr_t)(ip + 1)[1]), ((uintptr_t)(ip + 1)[2])); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + (3))); else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 456 "./ipret-1.inc"
{ _Bool ( *function_int_binary)(const mpint_t *s1, const mpint_t *s2, mpint_t *r, ajla_error_t *err); _Bool ( *function_int_binary_logical)(const mpint_t *s1, const mpint_t *s2, ajla_flat_option_t *r, ajla_error_t *err); _Bool ( *function_int_unary)(const mpint_t *s1, mpint_t *r, ajla_error_t *err);
# 655 "./ipret-1.inc"
label_int_binary_add_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_add_int8_t_1: function_int_binary = mpint_add; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_add_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_add_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_subtract_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_subtract_int8_t_1: function_int_binary = mpint_subtract; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_subtract_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_subtract_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_multiply_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_multiply_int8_t_1: function_int_binary = mpint_multiply; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_multiply_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_multiply_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_divide_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_divide_int8_t_1: function_int_binary = mpint_divide; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_divide_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_divide_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_modulo_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_modulo_int8_t_1: function_int_binary = mpint_modulo; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_modulo_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_modulo_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_power_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_power_int8_t_1: function_int_binary = mpint_power; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_power_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_power_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_and_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_and_int8_t_1: function_int_binary = mpint_and; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_and_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_and_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_or_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_or_int8_t_1: function_int_binary = mpint_or; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_or_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_or_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_xor_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_xor_int8_t_1: function_int_binary = mpint_xor; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_xor_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_xor_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shl_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shl_int8_t_1: function_int_binary = mpint_shl; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shl_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shl_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shr_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shr_int8_t_1: function_int_binary = mpint_shr; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shr_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shr_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bts_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_bts_int8_t_1: function_int_binary = mpint_bts; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bts_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_bts_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btr_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btr_int8_t_1: function_int_binary = mpint_btr; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btr_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btr_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btc_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btc_int8_t_1: function_int_binary = mpint_btc; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btc_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btc_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_equal_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_equal_int8_t_1: function_int_binary_logical = mpint_equal; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_equal_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_equal_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_equal_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_not_equal_int8_t_1: function_int_binary_logical = mpint_not_equal; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_not_equal_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_not_equal_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_int8_t_1: function_int_binary_logical = mpint_less; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_equal_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_equal_int8_t_1: function_int_binary_logical = mpint_less_equal; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_equal_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_equal_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bt_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_bt_int8_t_1: function_int_binary_logical = mpint_bt; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bt_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_bt_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_not_int8_t_1: function_int_unary = mpint_not; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_not_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_not_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_neg_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_neg_int8_t_1: function_int_unary = mpint_neg; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_neg_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_neg_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_inc_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_inc_int8_t_1: function_int_unary = mpint_inc; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_inc_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_inc_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_dec_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_dec_int8_t_1: function_int_unary = mpint_dec; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_dec_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_dec_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsf_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsf_int8_t_1: function_int_unary = mpint_bsf; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsf_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsf_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsr_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsr_int8_t_1: function_int_unary = mpint_bsr; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsr_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsr_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_popcnt_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_int8_t_1: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_to_int_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int8_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_from_int_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int64_t val1; int8_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int8_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_move_int8_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_copy_int8_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc_int8_t_1: do { frame_t slot; int8_t *val; ip_t sz; slot = ((uintptr_t)(ip + 1)[0]); ((void)(zero_())); val = (((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int8_t(val, ip + 1 + (1), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (1))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc16_int8_t_1: do { frame_t slot; int8_t *val; ip_t sz; slot = ((uintptr_t)(ip + 1)[0]); ((void)(zero_())); val = (((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int8_t(val, ip + 1 + (1), 1); __asm__ volatile ("":::"memory"); (ip += (1 + (1))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_add_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_add_int16_t_1: function_int_binary = mpint_add; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_add_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_add_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_subtract_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_subtract_int16_t_1: function_int_binary = mpint_subtract; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_subtract_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_subtract_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_multiply_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_multiply_int16_t_1: function_int_binary = mpint_multiply; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_multiply_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_multiply_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_divide_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_divide_int16_t_1: function_int_binary = mpint_divide; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_divide_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_divide_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_modulo_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_modulo_int16_t_1: function_int_binary = mpint_modulo; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_modulo_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_modulo_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_power_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_power_int16_t_1: function_int_binary = mpint_power; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_power_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_power_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_and_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_and_int16_t_1: function_int_binary = mpint_and; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_and_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_and_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_or_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_or_int16_t_1: function_int_binary = mpint_or; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_or_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_or_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_xor_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_xor_int16_t_1: function_int_binary = mpint_xor; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_xor_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_xor_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shl_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shl_int16_t_1: function_int_binary = mpint_shl; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shl_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shl_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shr_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shr_int16_t_1: function_int_binary = mpint_shr; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shr_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shr_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bts_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_bts_int16_t_1: function_int_binary = mpint_bts; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bts_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_bts_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btr_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btr_int16_t_1: function_int_binary = mpint_btr; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btr_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btr_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btc_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btc_int16_t_1: function_int_binary = mpint_btc; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btc_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btc_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_equal_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_equal_int16_t_1: function_int_binary_logical = mpint_equal; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_equal_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_equal_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_equal_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_not_equal_int16_t_1: function_int_binary_logical = mpint_not_equal; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_not_equal_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_not_equal_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_int16_t_1: function_int_binary_logical = mpint_less; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_equal_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_equal_int16_t_1: function_int_binary_logical = mpint_less_equal; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_equal_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_equal_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bt_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_bt_int16_t_1: function_int_binary_logical = mpint_bt; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bt_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_bt_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_not_int16_t_1: function_int_unary = mpint_not; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_not_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_not_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_neg_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_neg_int16_t_1: function_int_unary = mpint_neg; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_neg_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_neg_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_inc_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_inc_int16_t_1: function_int_unary = mpint_inc; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_inc_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_inc_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_dec_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_dec_int16_t_1: function_int_unary = mpint_dec; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_dec_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_dec_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsf_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsf_int16_t_1: function_int_unary = mpint_bsf; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsf_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsf_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsr_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsr_int16_t_1: function_int_unary = mpint_bsr; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsr_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsr_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_popcnt_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_int16_t_1: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_to_int_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int16_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_from_int_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int64_t val1; int16_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int16_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_move_int16_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_copy_int16_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc_int16_t_1: do { frame_t slot; int16_t *val; ip_t sz; slot = ((uintptr_t)(ip + 1)[0]); ((void)(zero_())); val = (((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int16_t(val, ip + 1 + (1), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (1))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc16_int16_t_1: do { frame_t slot; int16_t *val; ip_t sz; slot = ((uintptr_t)(ip + 1)[0]); ((void)(zero_())); val = (((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int16_t(val, ip + 1 + (1), 1); __asm__ volatile ("":::"memory"); (ip += (1 + (1))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_add_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_add_int32_t_1: function_int_binary = mpint_add; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_add_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_add_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_subtract_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_subtract_int32_t_1: function_int_binary = mpint_subtract; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_subtract_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_subtract_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_multiply_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_multiply_int32_t_1: function_int_binary = mpint_multiply; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_multiply_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_multiply_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_divide_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_divide_int32_t_1: function_int_binary = mpint_divide; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_divide_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_divide_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_modulo_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_modulo_int32_t_1: function_int_binary = mpint_modulo; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_modulo_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_modulo_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_power_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_power_int32_t_1: function_int_binary = mpint_power; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_power_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_power_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_and_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_and_int32_t_1: function_int_binary = mpint_and; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_and_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_and_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_or_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_or_int32_t_1: function_int_binary = mpint_or; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_or_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_or_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_xor_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_xor_int32_t_1: function_int_binary = mpint_xor; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_xor_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_xor_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shl_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shl_int32_t_1: function_int_binary = mpint_shl; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shl_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shl_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shr_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shr_int32_t_1: function_int_binary = mpint_shr; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shr_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shr_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bts_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_bts_int32_t_1: function_int_binary = mpint_bts; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bts_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_bts_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btr_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btr_int32_t_1: function_int_binary = mpint_btr; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btr_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btr_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btc_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btc_int32_t_1: function_int_binary = mpint_btc; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btc_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btc_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_equal_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_equal_int32_t_1: function_int_binary_logical = mpint_equal; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_equal_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_equal_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_equal_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_not_equal_int32_t_1: function_int_binary_logical = mpint_not_equal; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_not_equal_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_not_equal_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_int32_t_1: function_int_binary_logical = mpint_less; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_equal_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_equal_int32_t_1: function_int_binary_logical = mpint_less_equal; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_equal_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_equal_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bt_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_bt_int32_t_1: function_int_binary_logical = mpint_bt; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bt_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_bt_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_not_int32_t_1: function_int_unary = mpint_not; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_not_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_not_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_neg_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_neg_int32_t_1: function_int_unary = mpint_neg; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_neg_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_neg_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_inc_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_inc_int32_t_1: function_int_unary = mpint_inc; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_inc_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_inc_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_dec_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_dec_int32_t_1: function_int_unary = mpint_dec; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_dec_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_dec_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsf_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsf_int32_t_1: function_int_unary = mpint_bsf; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsf_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsf_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsr_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsr_int32_t_1: function_int_unary = mpint_bsr; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsr_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsr_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_popcnt_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_int32_t_1: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_to_int_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int32_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_from_int_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int64_t val1; int32_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int32_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_move_int32_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_copy_int32_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc_int32_t_1: do { frame_t slot; int32_t *val; ip_t sz; slot = ((uintptr_t)(ip + 1)[0]); ((void)(zero_())); val = (((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int32_t(val, ip + 1 + (1), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (1))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc16_int32_t_1: do { frame_t slot; int32_t *val; ip_t sz; slot = ((uintptr_t)(ip + 1)[0]); ((void)(zero_())); val = (((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int32_t(val, ip + 1 + (1), 1); __asm__ volatile ("":::"memory"); (ip += (1 + (1))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_add_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_add_int64_t_1: function_int_binary = mpint_add; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_add_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_add_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_subtract_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_subtract_int64_t_1: function_int_binary = mpint_subtract; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_subtract_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_subtract_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_multiply_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_multiply_int64_t_1: function_int_binary = mpint_multiply; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_multiply_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_multiply_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_divide_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_divide_int64_t_1: function_int_binary = mpint_divide; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_divide_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_divide_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_modulo_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_modulo_int64_t_1: function_int_binary = mpint_modulo; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_modulo_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_modulo_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_power_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_power_int64_t_1: function_int_binary = mpint_power; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_power_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_power_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_and_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_and_int64_t_1: function_int_binary = mpint_and; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_and_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_and_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_or_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_or_int64_t_1: function_int_binary = mpint_or; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_or_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_or_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_xor_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_xor_int64_t_1: function_int_binary = mpint_xor; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_xor_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_xor_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shl_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shl_int64_t_1: function_int_binary = mpint_shl; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shl_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shl_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shr_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shr_int64_t_1: function_int_binary = mpint_shr; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shr_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shr_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bts_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_bts_int64_t_1: function_int_binary = mpint_bts; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bts_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_bts_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btr_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btr_int64_t_1: function_int_binary = mpint_btr; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btr_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btr_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btc_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btc_int64_t_1: function_int_binary = mpint_btc; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btc_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btc_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_equal_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_equal_int64_t_1: function_int_binary_logical = mpint_equal; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_equal_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_equal_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_equal_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_not_equal_int64_t_1: function_int_binary_logical = mpint_not_equal; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_not_equal_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_not_equal_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_int64_t_1: function_int_binary_logical = mpint_less; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_equal_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_equal_int64_t_1: function_int_binary_logical = mpint_less_equal; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_equal_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_equal_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bt_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_bt_int64_t_1: function_int_binary_logical = mpint_bt; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bt_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_bt_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_not_int64_t_1: function_int_unary = mpint_not; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_not_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_not_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_neg_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_neg_int64_t_1: function_int_unary = mpint_neg; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_neg_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_neg_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_inc_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_inc_int64_t_1: function_int_unary = mpint_inc; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_inc_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_inc_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_dec_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_dec_int64_t_1: function_int_unary = mpint_dec; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_dec_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_dec_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsf_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsf_int64_t_1: function_int_unary = mpint_bsf; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsf_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsf_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsr_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsr_int64_t_1: function_int_unary = mpint_bsr; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsr_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsr_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_popcnt_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_int64_t_1: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_to_int_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int64_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_from_int_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int64_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_move_int64_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_copy_int64_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc_int64_t_1: do { frame_t slot; int64_t *val; ip_t sz; slot = ((uintptr_t)(ip + 1)[0]); ((void)(zero_())); val = (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int64_t(val, ip + 1 + (1), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (1))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc16_int64_t_1: do { frame_t slot; int64_t *val; ip_t sz; slot = ((uintptr_t)(ip + 1)[0]); ((void)(zero_())); val = (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int64_t(val, ip + 1 + (1), 1); __asm__ volatile ("":::"memory"); (ip += (1 + (1))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_add_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_add_int128_t_1: function_int_binary = mpint_add; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_add_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_add_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_subtract_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_subtract_int128_t_1: function_int_binary = mpint_subtract; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_subtract_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_subtract_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_multiply_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_multiply_int128_t_1: function_int_binary = mpint_multiply; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_multiply_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_multiply_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_divide_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_divide_int128_t_1: function_int_binary = mpint_divide; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_divide_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_divide_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_modulo_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_modulo_int128_t_1: function_int_binary = mpint_modulo; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_modulo_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_modulo_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_power_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_power_int128_t_1: function_int_binary = mpint_power; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_power_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_power_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_and_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_and_int128_t_1: function_int_binary = mpint_and; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_and_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_and_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_or_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_or_int128_t_1: function_int_binary = mpint_or; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_or_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_or_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_xor_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_xor_int128_t_1: function_int_binary = mpint_xor; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_xor_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_xor_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shl_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shl_int128_t_1: function_int_binary = mpint_shl; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shl_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shl_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shr_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shr_int128_t_1: function_int_binary = mpint_shr; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shr_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shr_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bts_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_bts_int128_t_1: function_int_binary = mpint_bts; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bts_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_bts_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btr_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btr_int128_t_1: function_int_binary = mpint_btr; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btr_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btr_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btc_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btc_int128_t_1: function_int_binary = mpint_btc; goto escape_int_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btc_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btc_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_equal_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_equal_int128_t_1: function_int_binary_logical = mpint_equal; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_equal_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_equal_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_equal_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_not_equal_int128_t_1: function_int_binary_logical = mpint_not_equal; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_not_equal_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_not_equal_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_int128_t_1: function_int_binary_logical = mpint_less; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_equal_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_equal_int128_t_1: function_int_binary_logical = mpint_less_equal; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_equal_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_equal_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bt_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_bt_int128_t_1: function_int_binary_logical = mpint_bt; goto escape_int_binary_logical_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bt_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_bt_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_not_int128_t_1: function_int_unary = mpint_not; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_not_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_not_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_neg_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_neg_int128_t_1: function_int_unary = mpint_neg; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_neg_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_neg_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_inc_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_inc_int128_t_1: function_int_unary = mpint_inc; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_inc_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_inc_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_dec_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_dec_int128_t_1: function_int_unary = mpint_dec; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_dec_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_dec_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsf_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsf_int128_t_1: function_int_unary = mpint_bsf; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsf_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsf_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsr_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsr_int128_t_1: function_int_unary = mpint_bsr; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsr_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsr_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_popcnt_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_int128_t_1: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_to_int_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int128_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_from_int_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { int64_t val1; int128_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int128_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_move_int128_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_copy_int128_t_1: do { do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc_int128_t_1: do { frame_t slot; int128_t *val; ip_t sz; slot = ((uintptr_t)(ip + 1)[0]); ((void)(zero_())); val = (((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int128_t(val, ip + 1 + (1), 0); __asm__ volatile ("":::"memory"); (ip += (1 + (1))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc16_int128_t_1: do { frame_t slot; int128_t *val; ip_t sz; slot = ((uintptr_t)(ip + 1)[0]); ((void)(zero_())); val = (((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int128_t(val, ip + 1 + (1), 1); __asm__ volatile ("":::"memory"); (ip += (1 + (1))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

escape_int_binary_thunk_1: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_int_binary_operator(fp, ip, ((uintptr_t)(ip + 1)[0]), ((uintptr_t)(ip + 1)[1]), ((uintptr_t)(ip + 1)[2]), ((uintptr_t)(ip + 1)[3]), function_int_binary); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + (4))); else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 667 "./ipret-1.inc"
escape_int_binary_logical_thunk_1: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_int_binary_logical_operator(fp, ip, ((uintptr_t)(ip + 1)[0]), ((uintptr_t)(ip + 1)[1]), ((uintptr_t)(ip + 1)[2]), ((uintptr_t)(ip + 1)[3]), function_int_binary_logical); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + (4))); else if (ex != ((void *)(uintptr_t)1)) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 677 "./ipret-1.inc"
escape_int_unary_thunk_1: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_int_unary_operator(fp, ip, ((uintptr_t)(ip + 1)[0]), ((uintptr_t)(ip + 1)[1]), ((uintptr_t)(ip + 1)[2]), function_int_unary); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + (3))); else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 688 "./ipret-1.inc"
# 1 "./for-fix.inc" 1
# 24 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_bsr_alt1_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_alt1_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_popcnt_alt1_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_alt1_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 74 "./ipret-a1.inc" 2
# 25 "./for-fix.inc" 2
# 36 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_bsr_alt1_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_alt1_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_popcnt_alt1_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_alt1_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 74 "./ipret-a1.inc" 2
# 37 "./for-fix.inc" 2
# 48 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_bsr_alt1_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_alt1_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_popcnt_alt1_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_alt1_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 74 "./ipret-a1.inc" 2
# 49 "./for-fix.inc" 2
# 60 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_bsr_alt1_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_alt1_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_popcnt_alt1_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_alt1_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 74 "./ipret-a1.inc" 2
# 61 "./for-fix.inc" 2
# 72 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_bsr_alt1_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_alt1_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_popcnt_alt1_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_alt1_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 74 "./ipret-a1.inc" 2
# 73 "./for-fix.inc" 2
# 689 "./ipret-1.inc" 2


# 1 "./for-int.inc" 1
# 24 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_int_binary_popcnt_alt1_int8_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_alt1_int8_t_1: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_alt1_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_alt1_int8_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 38 "./ipret-a2.inc" 2
# 25 "./for-int.inc" 2
# 36 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_int_binary_popcnt_alt1_int16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_alt1_int16_t_1: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_alt1_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_alt1_int16_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 38 "./ipret-a2.inc" 2
# 37 "./for-int.inc" 2
# 48 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_int_binary_popcnt_alt1_int32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_alt1_int32_t_1: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_alt1_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_alt1_int32_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 38 "./ipret-a2.inc" 2
# 49 "./for-int.inc" 2
# 60 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_int_binary_popcnt_alt1_int64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_alt1_int64_t_1: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_alt1_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_alt1_int64_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 38 "./ipret-a2.inc" 2
# 61 "./for-int.inc" 2
# 72 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_int_binary_popcnt_alt1_int128_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_alt1_int128_t_1: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_alt1_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_alt1_int128_t_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 38 "./ipret-a2.inc" 2
# 73 "./for-int.inc" 2
# 692 "./ipret-1.inc" 2


# 1 "./for-real.inc" 1
# 23 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_add_alt1_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_subtract_alt1_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_multiply_alt1_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_divide_alt1_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_equal_alt1_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_not_equal_alt1_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_alt1_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_equal_alt1_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 118 "./ipret-a3.inc" 2
# 149 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_to_int_alt1_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_alt1_real16_t((((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 150 "./ipret-a3.inc" 2
# 163 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_from_int_alt1_real16_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_alt1_real16_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 164 "./ipret-a3.inc" 2
# 24 "./for-real.inc" 2
# 33 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_add_alt1_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_add_alt2_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_subtract_alt1_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_subtract_alt2_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_multiply_alt1_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_multiply_alt2_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_divide_alt1_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_divide_alt2_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_equal_alt1_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_equal_alt2_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_not_equal_alt1_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_not_equal_alt2_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_alt1_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_alt2_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_equal_alt1_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_equal_alt2_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 118 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_neg_alt1_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_alt1_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 125 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_neg_alt2_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_alt2_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 131 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_sqrt_alt1_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_alt1_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 137 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_sqrt_alt2_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_alt2_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 143 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_to_int_alt1_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_alt1_real32_t((((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 150 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_to_int_alt2_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_alt2_real32_t((((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 157 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_from_int_alt1_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_alt1_real32_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 164 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_from_int_alt2_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_alt2_real32_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 171 "./ipret-a3.inc" 2







# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_is_exception_alt1_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_alt1_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 179 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_is_exception_alt2_real32_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_alt2_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 185 "./ipret-a3.inc" 2
# 34 "./for-real.inc" 2
# 43 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_add_alt1_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_add_alt2_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_subtract_alt1_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_subtract_alt2_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_multiply_alt1_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_multiply_alt2_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_divide_alt1_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_divide_alt2_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_equal_alt1_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_equal_alt2_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_not_equal_alt1_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_not_equal_alt2_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_alt1_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_alt2_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_equal_alt1_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_equal_alt2_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_1; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_1; } __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 118 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_neg_alt1_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_alt1_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 125 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_neg_alt2_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_alt2_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 131 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_sqrt_alt1_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_alt1_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 137 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_sqrt_alt2_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_alt2_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 143 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_to_int_alt1_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_alt1_real64_t((((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 150 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_to_int_alt2_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_alt2_real64_t((((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 157 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_from_int_alt1_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_alt1_real64_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 164 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_from_int_alt2_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_1; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_alt2_real64_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 171 "./ipret-a3.inc" 2







# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_is_exception_alt1_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_alt1_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 179 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_is_exception_alt2_real64_t_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_1; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_alt2_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 185 "./ipret-a3.inc" 2
# 44 "./for-real.inc" 2
# 53 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 54 "./for-real.inc" 2
# 695 "./ipret-1.inc" 2

}
# 748 "./ipret-1.inc"
label_bool_binary_and_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { ((void)(zero_())); goto escape_bool_binary_thunk_1; } else { ajla_flat_option_t val1; ajla_flat_option_t val2; ajla_flat_option_t result; __asm__ volatile ("":::"memory"); val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); val2 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); result = val1 & val2; *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = result; __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
label_bool_binary_or_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { ((void)(zero_())); goto escape_bool_binary_thunk_1; } else { ajla_flat_option_t val1; ajla_flat_option_t val2; ajla_flat_option_t result; __asm__ volatile ("":::"memory"); val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); val2 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); result = val1 | val2; *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = result; __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
label_bool_binary_equal_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { ((void)(zero_())); goto escape_bool_binary_thunk_1; } else { ajla_flat_option_t val1; ajla_flat_option_t val2; ajla_flat_option_t result; __asm__ volatile ("":::"memory"); val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); val2 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); result = val1 == val2; *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = result; __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
label_bool_binary_not_equal_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { ((void)(zero_())); goto escape_bool_binary_thunk_1; } else { ajla_flat_option_t val1; ajla_flat_option_t val2; ajla_flat_option_t result; __asm__ volatile ("":::"memory"); val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); val2 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); result = val1 ^ val2; *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = result; __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
label_bool_binary_less_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { ((void)(zero_())); goto escape_bool_binary_thunk_1; } else { ajla_flat_option_t val1; ajla_flat_option_t val2; ajla_flat_option_t result; __asm__ volatile ("":::"memory"); val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); val2 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); result = val1 < val2; *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = result; __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
label_bool_binary_less_equal_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_2 = ((uintptr_t)(ip + 1)[1]); frame_t slot_r = ((uintptr_t)(ip + 1)[2]); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { ((void)(zero_())); goto escape_bool_binary_thunk_1; } else { ajla_flat_option_t val1; ajla_flat_option_t val2; ajla_flat_option_t result; __asm__ volatile ("":::"memory"); val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); val2 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); result = val1 <= val2; *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = result; __asm__ volatile ("":::"memory"); (ip += (1 + (4))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
label_bool_unary_not_1: do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_bool_unary_thunk_1; } else { ajla_flat_option_t val1; ajla_flat_option_t result; __asm__ volatile ("":::"memory"); val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); result = val1 ^ 1; *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = result; __asm__ volatile ("":::"memory"); (ip += (1 + (3))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

escape_bool_binary_thunk_1: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_bool_operator(fp, ip, ((uintptr_t)(ip + 1)[0]), ((uintptr_t)(ip + 1)[1]), ((uintptr_t)(ip + 1)[2]), ((uintptr_t)(ip + 1)[3])); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + (4))); else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 766 "./ipret-1.inc"
escape_bool_unary_thunk_1: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_bool_operator(fp, ip, ((uintptr_t)(ip + 1)[0]), ((frame_t)-1), ((uintptr_t)(ip + 1)[1]), ((uintptr_t)(ip + 1)[2])); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + (3))); else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 777 "./ipret-1.inc"
label_bool_move_1: do {

 do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0);

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_bool_copy_1: do {

 do { frame_t slot_1 = ((uintptr_t)(ip + 1)[0]); frame_t slot_r = ((uintptr_t)(ip + 1)[1]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + (2))); } while (0);

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


label_OPCODE_INT_LDC_LONG1: do {

 frame_t slot;
 ip_t sz;
 slot = ((uintptr_t)(ip + 1)[0]);
 sz = u_ipret_int_ldc_long(fp, slot, ip + 1 + (1));
 (ip += (1 + (1)));
 (ip += (sz));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


label_OPCODE_IS_EXCEPTION1: do {

 frame_t slot_1 = ((uintptr_t)(ip + 1)[0]);
 frame_t slot_r = ((uintptr_t)(ip + 1)[1]);
 ((void)(zero_()));
 if (!frame_variable_is_flat(fp, slot_1)) {
  void *ex = u_is_thunk_operator(fp, ip, slot_1, slot_r, ((uintptr_t)(ip + 1)[2]));
  if (ex == ((void *)(uintptr_t)3))
   (ip += (1 + (3)));
  else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0)))
   do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
 } else {
  __asm__ volatile ("":::"memory");
  *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = 0;
  __asm__ volatile ("":::"memory");
  (ip += (1 + (3)));
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_EXCEPTION_CLASS1: do {

 void *ex;
 ex = u_thunk_get_param(fp, ip, ((uintptr_t)(ip + 1)[0]), ((uintptr_t)(ip + 1)[1]), ((uintptr_t)(ip + 1)[2]), 0);
 if ((__builtin_expect((int)(ex == ((void *)(uintptr_t)3)), 1)))
  (ip += (1 + (3)));
 else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_EXCEPTION_TYPE1: do {

 void *ex;
 ex = u_thunk_get_param(fp, ip, ((uintptr_t)(ip + 1)[0]), ((uintptr_t)(ip + 1)[1]), ((uintptr_t)(ip + 1)[2]), 1);
 if ((__builtin_expect((int)(ex == ((void *)(uintptr_t)3)), 1)))
  (ip += (1 + (3)));
 else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_EXCEPTION_AUX1: do {

 void *ex;
 ex = u_thunk_get_param(fp, ip, ((uintptr_t)(ip + 1)[0]), ((uintptr_t)(ip + 1)[1]), ((uintptr_t)(ip + 1)[2]), 2);
 if ((__builtin_expect((int)(ex == ((void *)(uintptr_t)3)), 1)))
  (ip += (1 + (3)));
 else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_SYSTEM_PROPERTY1: do {

 void *ex;
 ex = u_ipret_get_system_property(fp, ip, ((uintptr_t)(ip + 1)[0]), ((uintptr_t)(ip + 1)[1]));
 if ((__builtin_expect((int)(ex == ((void *)(uintptr_t)3)), 1)))
  (ip += (1 + (3)));
 else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


label_OPCODE_FLAT_MOVE1: do {

 frame_t slot_1 = ((uintptr_t)(ip + 1)[0]);
 frame_t slot_r = ((uintptr_t)(ip + 1)[1]);
 if ((__builtin_expect((int)(frame_variable_is_flat(fp, slot_1)), 1))) {
  memcpy((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), frame_get_type_of_local(fp, slot_1)->size);
 } else {
  pointer_t ptr = frame_get_pointer_reference(fp, slot_1, 1);
  frame_set_pointer(fp, slot_r, ptr);
 }
 (ip += (1 + (2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_FLAT_COPY1: do {

 frame_t slot_1 = ((uintptr_t)(ip + 1)[0]);
 frame_t slot_r = ((uintptr_t)(ip + 1)[1]);
 if ((__builtin_expect((int)(frame_variable_is_flat(fp, slot_1)), 1))) {
  memcpy((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), frame_get_type_of_local(fp, slot_1)->size);
 } else {
  pointer_t ptr = frame_get_pointer_reference(fp, slot_1, 0);
  frame_set_pointer(fp, slot_r, ptr);
 }
 (ip += (1 + (2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_REF_MOVE1: do {

 frame_t slot_1 = ((uintptr_t)(ip + 1)[0]);
 frame_t slot_r = ((uintptr_t)(ip + 1)[1]);
 pointer_t ptr = frame_get_pointer_reference(fp, slot_1, 1);
 pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))));
 frame_set_pointer(fp, slot_r, ptr);
 (ip += (1 + (2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_REF_MOVE_CLEAR1: do {

 frame_t slot_1 = ((uintptr_t)(ip + 1)[0]);
 frame_t slot_r = ((uintptr_t)(ip + 1)[1]);
 pointer_t ptr = frame_get_pointer_reference(fp, slot_1, 1);
 frame_set_pointer(fp, slot_r, ptr);
 (ip += (1 + (2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_REF_COPY1: do {

 frame_t slot_1 = ((uintptr_t)(ip + 1)[0]);
 frame_t slot_r = ((uintptr_t)(ip + 1)[1]);
 pointer_t ptr = frame_get_pointer_reference(fp, slot_1, 0);
 frame_set_pointer(fp, slot_r, ptr);
 (ip += (1 + (2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_BOX_MOVE_CLEAR1: do {

 frame_t slot_1 = ((uintptr_t)(ip + 1)[0]);
 frame_t slot_r = ((uintptr_t)(ip + 1)[1]);
 pointer_t ptr = u_ipret_copy_variable_to_pointer(fp, slot_1, 1);
 *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = pointer_empty();
 frame_set_pointer(fp, slot_r, ptr);
 (ip += (1 + (2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_BOX_COPY1: do {

 frame_t slot_1 = ((uintptr_t)(ip + 1)[0]);
 frame_t slot_r = ((uintptr_t)(ip + 1)[1]);
 pointer_t ptr = u_ipret_copy_variable_to_pointer(fp, slot_1, 0);
 frame_set_pointer(fp, slot_r, ptr);
 (ip += (1 + (2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_TAKE_BORROWED1: do {

 frame_t slot = ((uintptr_t)(ip + 1)[0]);
 if (!frame_test_and_set_flag(fp, slot)) {
  pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
  pointer_reference_owned(ptr);
 }
 (ip += (1 + (1)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


label_OPCODE_DEREFERENCE1: do {

 frame_t slot = ((uintptr_t)(ip + 1)[0]);
# 971 "./ipret-1.inc"
 frame_free(fp, slot);
 pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))));
 (ip += (1 + (1)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_DEREFERENCE_CLEAR1: do {

 frame_t slot = ((uintptr_t)(ip + 1)[0]);
# 989 "./ipret-1.inc"
 frame_free_and_clear(fp, slot);
 (ip += (1 + (1)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_EVAL1: do {

 frame_t slot = ((uintptr_t)(ip + 1)[0]);
 if (frame_test_flag(fp, slot)) {
  pointer_t *ptr = (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
  struct data __attribute__((__unused__)) *result;

  do { pointer_t p_; if (!(1)) p_ = pointer_locked_read(ptr); else p_ = *(ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (result) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1003"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(ptr, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(ptr) , "./ipret-1.inc" ":" "1003"); { goto eval_skip_1; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);
# 1010 "./ipret-1.inc"
eval_skip_1:;
 }
 (ip += (1 + (1)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


label_OPCODE_CHECKPOINT1: do {


 frame_t id = ((uintptr_t)(ip + 1)[0]);
 const code_t __attribute__((__unused__)) *orig_ip = ip;

 (ip += (1 + (1)));

 if ((__builtin_expect((int)(((__builtin_expect((int)(*(&ts) != __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)), 0)))), 0)) && (__builtin_expect((int)(frame_execution_control(fp) != ((void*)0)), 1))) {
  do { void *ex_ = u_ipret_tick(fp, ip); do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0);
 } else {

  struct data *fn = (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function;
  code_return_t r;
  void *new_fp;
  ip_t new_ip;
  struct data *codegen;
  if ((__builtin_expect((int)(__c11_atomic_load(&((((void)(zero_()))), &(fn)->u_.function)->codegen_failed, 0)), 0)))
   goto checkpoint_exit_1;

  do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(&((((void)(zero_()))), &(fn)->u_.function)->codegen); else p_ = *(&((((void)(zero_()))), &(fn)->u_.function)->codegen); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (codegen) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1041"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(&((((void)(zero_()))), &(fn)->u_.function)->codegen, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(&((((void)(zero_()))), &(fn)->u_.function)->codegen) , "./ipret-1.inc" ":" "1041"); { __c11_atomic_store(&((((void)(zero_()))), &(fn)->u_.function)->codegen_failed, 1, 0); goto checkpoint_exit_1;; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, orig_ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);
# 1068 "./ipret-1.inc"
  r = u_codegen_entry(fp, &u_cg_upcall_vector, ts, ((((void)(zero_()))), &(codegen)->u_.codegen)->unoptimized_code[id]);
# 1078 "./ipret-1.inc"
  new_fp = r.fp;
  new_ip = r.ip;


  if ((__builtin_expect((int)(new_ip == (ip_t)-1), 0))) {

   do { if ((new_fp) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((new_fp)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((new_fp)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
  } else {

   fp = new_fp;
   ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + new_ip;
   if ((__builtin_expect((int)(profiling_escapes), 0))) {
    profile_counter_t profiling_counter;
    fn = (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function;
    profiling_counter = __c11_atomic_load(&((((void)(zero_()))), &(fn)->u_.function)->escape_data[new_ip].counter, 0);
    profiling_counter++;
    __c11_atomic_store(&((((void)(zero_()))), &(fn)->u_.function)->escape_data[new_ip].counter, profiling_counter, 0);
   }
  }

  goto checkpoint_exit_1;
checkpoint_exit_1:;
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 1134 "./ipret-1.inc"
label_OPCODE_JMP_FALSE1: do {

 int32_t offset;
 frame_t slot;
 ajla_flat_option_t val1;

 slot = ((uintptr_t)(ip + 1)[0]);
 if ((__builtin_expect((int)(frame_test_flag(fp, slot)), 0))) {
  void *ex = u_thunk_bool_jump(fp, ip, slot);
  if (ex != ((void *)(uintptr_t)1)) {
   if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)2)), 1))) {
    do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
   } else {
    if (4 == 2) {
     offset = ip[1 + (1) + 1];
     (ip += (1 + (1)));
     (ip += (2));
    } else if (4 == 4) {
     offset = get_unaligned_32(&ip[1 + (1) + 2]);
     (ip += (1 + (1)));
     (ip += (4));
    } else {
     not_reached();
    }
    ip = ((const code_t *)(void *)(((const char *)(void *)(ip)) + offset));
    goto jmp_false_exception_1;
   }
  }
 }
 __asm__ volatile ("":::"memory");
 val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
 __asm__ volatile ("":::"memory");
 if (4 == 2) {
  offset = ip[1 + (1)];
  (ip += (1 + (1)));
  (ip += (2));
 } else if (4 == 4) {
  offset = get_unaligned_32(&ip[1 + (1)]);
  (ip += (1 + (1)));
  (ip += (4));
 } else {
  not_reached();
 }
 if (!val1)
  ip = ((const code_t *)(void *)(((const char *)(void *)(ip)) + offset));

jmp_false_exception_1:;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 1193 "./ipret-1.inc"
{ pointer_t *direct_data; pointer_t indirect_data; arg_t n_arguments; frame_t result_slot; struct thunk *function_error;







label_OPCODE_LOAD_FN1: do {

 struct data *new_reference;
 pointer_t result_ptr;

 n_arguments = ((uintptr_t)(ip + 1)[0]);
 result_slot = ((uintptr_t)(ip + 1)[1]);
 direct_data = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->local_directory[((uintptr_t)(ip + 1)[2])];
 indirect_data = pointer_empty();

 (ip += (1 + (3)));

fn_copy_arguments_1:

 new_reference = u_data_alloc_function_reference_mayfail(n_arguments, &ajla_error , "./ipret-1.inc" ":" "1215");
 if ((__builtin_expect((int)(!new_reference), 0))) {
  function_error = u_thunk_alloc_exception_error(ajla_error, ((void*)0), fp, ip , "./ipret-1.inc" ":" "1217");
  if (!direct_data)
   u_pointer_dereference_(indirect_data , "./ipret-1.inc" ":" "1219");

  ip = free_parameters_1(fp, ip, n_arguments);
  result_ptr = pointer_thunk(function_error);
 } else {
  arg_t i;
  if (direct_data) {
   ((((void)(zero_()))), &(new_reference)->u_.function_reference)->is_indirect = 0;
   ((((void)(zero_()))), &(new_reference)->u_.function_reference)->u.direct = direct_data;
  } else {
   ((((void)(zero_()))), &(new_reference)->u_.function_reference)->is_indirect = 1;
   ((((void)(zero_()))), &(new_reference)->u_.function_reference)->u.indirect = indirect_data;
  }
  for (i = 0; i < n_arguments; i++) {
   u_ipret_fill_function_reference_from_slot(new_reference, i, fp, ((uintptr_t)(ip)[0]), (((uintptr_t)(ip)[1]) & 0x0002) != 0);
   (ip += ((2)));
  }
  result_ptr = pointer_data(new_reference);
 }

 frame_set_pointer(fp, result_slot, result_ptr);

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CURRY1: do {

 frame_t fn_ref_slot;

 n_arguments = ((uintptr_t)(ip + 1)[0]);
 result_slot = ((uintptr_t)(ip + 1)[1]);

 fn_ref_slot = ((uintptr_t)(ip + 1)[2]);
 direct_data = ((void*)0);
 indirect_data = frame_get_pointer_reference(fp, fn_ref_slot, (((uintptr_t)(ip + 1)[3]) & 0x0002) != 0);

 (ip += (1 + (4)));

 goto fn_copy_arguments_1;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

}

{ arg_t n_arguments; arg_t n_return_values; struct thunk *function_error; struct data *function; const code_t *orig_ip; frame_s *new_fp; arg_t i; pointer_t *direct_function; pointer_t indirect_function; unsigned char mode;
# 1274 "./ipret-1.inc"
label_OPCODE_CALL1: do {

 pointer_t *function_ptr;

 mode = 1;
call_from_mode_1:

 n_arguments = ((uintptr_t)(ip + 1)[0]);
 n_return_values = ((uintptr_t)(ip + 1)[1]);
 function_ptr = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->local_directory[((uintptr_t)(ip + 1)[2])];

 do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(function_ptr); else p_ = *(function_ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (function) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1291"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(function_ptr, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(function_ptr) , "./ipret-1.inc" ":" "1291"); { function_error = thunk_; thunk_reference(function_error); (ip += (1 + (3))); goto call_set_error_1;; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);







 ((void)(zero_()));





 (ip += (1 + (3)));

 new_fp = frame_build(fp, function, &ajla_error);
 if ((__builtin_expect((int)(!new_fp), 0))) {
call_allocation_error_1:
  function_error = u_thunk_alloc_exception_error(ajla_error, ((void*)0), fp, ip , "./ipret-1.inc" ":" "1304");
call_set_error_1:
  ip = free_parameters_1(fp, ip, n_arguments);
  pointer_reference_owned_multiple(pointer_thunk(function_error), n_return_values - 1);
  i = n_return_values;
  while (1) {
   frame_t slot_r = get_unaligned_32(&(ip)[(0) * 2]);
   (ip += (((1) * 2) + 1));
   frame_set_pointer(fp, slot_r, pointer_thunk(function_error));
   if (!--i)
    break;
  }
 } else {
  fp = frame_up(new_fp);
  frame_init(new_fp, function, (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->timestamp, mode);

  i = 0;
call_copy_arguments_1:
  for (; i < ((((void)(zero_()))), &(function)->u_.function)->n_arguments; i++) {
   frame_t src_slot = ((uintptr_t)(ip)[0]);
   frame_t dst_slot = ((((void)(zero_()))), &(function)->u_.function)->args[i].slot;
   unsigned char src_flag = (unsigned char)((uintptr_t)(ip)[1]);
   _Bool may_be_borrowed = ((((void)(zero_()))), &(function)->u_.function)->args[i].may_be_borrowed;
   if (may_be_borrowed && src_flag & 0x0004 && !pointer_is_thunk(*(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(src_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))))) {
    *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(new_fp))) + ((size_t)(dst_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(src_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
   } else if (may_be_borrowed && src_flag & 0x0008 && !frame_test_flag(fp, src_slot) && !pointer_is_thunk(*(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(src_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))))) {
    *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(new_fp))) + ((size_t)(dst_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(src_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
    *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(src_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = pointer_empty();
   } else {
    u_ipret_copy_variable(fp, src_slot, new_fp, dst_slot, (src_flag & 0x0002) != 0);
   }
   (ip += ((2)));
  }
  (((struct frame_struct *)(void *)(((const char *)(void *)(new_fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->previous_ip = frame_ip(fp, ip);

  fp = new_fp;
  ip = &((((void)(zero_()))), &(function)->u_.function)->code[0];

  if ((__builtin_expect((int)(mode == 3), 0))) {
   do { void *ex_ = u_ipret_tick(fp, ip); do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0);
  }
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_STRICT1: do {

 mode = 2;
 goto call_from_mode_1;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_SPARK1: do {

 mode = 3;
 goto call_from_mode_1;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_INDIRECT1: do {

 frame_t fn_ref_slot;
 _Bool deref;
 pointer_t *ptr;

 mode = 1;
call_indirect_from_mode_1:

 orig_ip = ip;
 n_arguments = ((uintptr_t)(ip + 1)[0]);
 n_return_values = ((uintptr_t)(ip + 1)[1]);
 fn_ref_slot = ((uintptr_t)(ip + 1)[2]);
 deref = (((uintptr_t)(ip + 1)[3]) & 0x0002) != 0;
 (ip += (1 + (4)));

 ptr = (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(fn_ref_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
 while (1) {
  do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(ptr); else p_ = *(ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (function) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1388"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(ptr, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(ptr) , "./ipret-1.inc" ":" "1388"); { function_error = thunk_; thunk_reference(function_error); if (deref) frame_free_and_clear(fp, fn_ref_slot); goto call_set_error_1; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, orig_ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);







  if (!((((void)(zero_()))), &(function)->u_.function_reference)->is_indirect)
   break;
  ptr = &((((void)(zero_()))), &(function)->u_.function_reference)->u.indirect;
 }
 ptr = ((((void)(zero_()))), &(function)->u_.function_reference)->u.direct;
 do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(ptr); else p_ = *(ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (function) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1401"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(ptr, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(ptr) , "./ipret-1.inc" ":" "1401"); { function_error = thunk_; thunk_reference(function_error); if (deref) frame_free_and_clear(fp, fn_ref_slot); goto call_set_error_1; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, orig_ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);
# 1403 "./ipret-1.inc"
 new_fp = frame_build(fp, function, &ajla_error);
 if ((__builtin_expect((int)(!new_fp), 0))) {
  if (deref)
   frame_free_and_clear(fp, fn_ref_slot);
  goto call_allocation_error_1;
 } else {
  fp = frame_up(new_fp);
  frame_init(new_fp, function, (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->timestamp, mode);

  i = ((((void)(zero_()))), &(function)->u_.function)->n_arguments - n_arguments;

  u_copy_from_function_reference_to_frame(new_fp, pointer_get_data_(*(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(fn_ref_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) , "./ipret-1.inc" ":" "1414"), i, deref && frame_test_flag(fp, fn_ref_slot));
  if (deref)
   frame_free_and_clear(fp, fn_ref_slot);

  goto call_copy_arguments_1;
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_INDIRECT_STRICT1: do {

 mode = 2;
 goto call_indirect_from_mode_1;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_INDIRECT_SPARK1: do {

 mode = 3;
 goto call_indirect_from_mode_1;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_LAZY1: do {

 struct data *function_reference;
 struct thunk **results;

 n_arguments = ((uintptr_t)(ip + 1)[0]);
 n_return_values = ((uintptr_t)(ip + 1)[1]);
 direct_function = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->local_directory[((uintptr_t)(ip + 1)[2])];
 indirect_function = pointer_empty();

 (ip += (1 + (3)));

call_lazy_copy_arguments_1:
 results = ((__builtin_expect((int)(!mem_check_overflow(0, n_return_values, sizeof(struct thunk *), &ajla_error)), 0)) ? ((struct thunk **)(void *)(((void*)0))) : ((struct thunk **)(void *)(mem_alloc_position((((size_t)(0) + (size_t)(n_return_values) * (size_t)(sizeof(struct thunk *))) >= ((size_t)(0)) + (zero_()) ? ((size_t)(0) + (size_t)(n_return_values) * (size_t)(sizeof(struct thunk *))) : ((size_t)(0))), &ajla_error , "./ipret-1.inc" ":" "1450"))));
 if ((__builtin_expect((int)(!results), 0))) {
  if (!direct_function)
   u_pointer_dereference_(indirect_function , "./ipret-1.inc" ":" "1453");
  goto call_allocation_error_1;
 }

 if (!(function_reference = u_data_alloc_function_reference_mayfail(n_arguments, &ajla_error , "./ipret-1.inc" ":" "1457"))) {
  if (!direct_function)
   u_pointer_dereference_(indirect_function , "./ipret-1.inc" ":" "1459");
  mem_free_position(results , "./ipret-1.inc" ":" "1460");
  goto call_allocation_error_1;
 }
 if (direct_function) {
  ((((void)(zero_()))), &(function_reference)->u_.function_reference)->is_indirect = 0;
  ((((void)(zero_()))), &(function_reference)->u_.function_reference)->u.direct = direct_function;
 } else {
  ((((void)(zero_()))), &(function_reference)->u_.function_reference)->is_indirect = 1;
  ((((void)(zero_()))), &(function_reference)->u_.function_reference)->u.indirect = indirect_function;
 }

 if (!u_thunk_alloc_function_call(pointer_data(function_reference), n_return_values, results, &ajla_error)) {
  if (!direct_function)
   u_pointer_dereference_(indirect_function , "./ipret-1.inc" ":" "1473");
  mem_free_position(results , "./ipret-1.inc" ":" "1474");
  do { ((void)(zero_())); do { refcount_poison_tag_(&(function_reference)->refcount_, "./ipret-1.inc" ":" "1475");; mem_free_aligned_position(data_untag_(function_reference, "./ipret-1.inc" ":" "1475") , "./ipret-1.inc" ":" "1475"); } while (0); } while (0);
  goto call_allocation_error_1;
 }

 for (i = 0; i < n_arguments; i++) {
  frame_t src_slot = ((uintptr_t)(ip)[0]);
  unsigned char src_flag = (unsigned char)((uintptr_t)(ip)[1]);
  u_ipret_fill_function_reference_from_slot(function_reference, i, fp, src_slot, (src_flag & 0x0002) != 0);
  (ip += ((2)));
 }

 for (i = 0; i < n_return_values; i++) {
  frame_t slot_r = get_unaligned_32(&(ip)[(0) * 2]);
  frame_set_pointer(fp, slot_r, pointer_thunk(results[i]));
  (ip += (((1) * 2) + 1));
 }

 mem_free_position(results , "./ipret-1.inc" ":" "1492");

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_INDIRECT_LAZY1: do {

 frame_t fn_ref_slot;
 _Bool deref;

 n_arguments = ((uintptr_t)(ip + 1)[0]);
 n_return_values = ((uintptr_t)(ip + 1)[1]);
 fn_ref_slot = ((uintptr_t)(ip + 1)[2]);
 deref = (((uintptr_t)(ip + 1)[3]) & 0x0002) != 0;
 (ip += (1 + (4)));

 indirect_function = frame_get_pointer_reference(fp, fn_ref_slot, deref);
 direct_function = ((void*)0);

 goto call_lazy_copy_arguments_1;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_CACHE1: do {

 struct ipret_call_cache_arg *arguments;
 frame_t *return_values;
 void *ex;

call_cache_1:
 orig_ip = ip;
 n_arguments = ((uintptr_t)(ip + 1)[0]);
 n_return_values = ((uintptr_t)(ip + 1)[1]);
 direct_function = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->local_directory[((uintptr_t)(ip + 1)[2])];
 (ip += (1 + (3)));

 do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(direct_function); else p_ = *(direct_function); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (function) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1532"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(direct_function, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(direct_function) , "./ipret-1.inc" ":" "1532"); { function_error = thunk_; thunk_reference(function_error); goto call_set_error_1;; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, orig_ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);





 ((void)(zero_()));




 arguments = ((__builtin_expect((int)(!mem_check_overflow(0, n_arguments, sizeof(struct ipret_call_cache_arg), &ajla_error)), 0)) ? ((struct ipret_call_cache_arg *)(void *)(((void*)0))) : ((struct ipret_call_cache_arg *)(void *)(mem_alloc_position((((size_t)(0) + (size_t)(n_arguments) * (size_t)(sizeof(struct ipret_call_cache_arg))) >= ((size_t)(0)) + (zero_()) ? ((size_t)(0) + (size_t)(n_arguments) * (size_t)(sizeof(struct ipret_call_cache_arg))) : ((size_t)(0))), &ajla_error , "./ipret-1.inc" ":" "1538"))));
 if (!arguments) {
  goto call_allocation_error_1;
 }
 return_values = ((__builtin_expect((int)(!mem_check_overflow(0, n_return_values, sizeof(frame_t), &ajla_error)), 0)) ? ((frame_t *)(void *)(((void*)0))) : ((frame_t *)(void *)(mem_alloc_position((((size_t)(0) + (size_t)(n_return_values) * (size_t)(sizeof(frame_t))) >= ((size_t)(0)) + (zero_()) ? ((size_t)(0) + (size_t)(n_return_values) * (size_t)(sizeof(frame_t))) : ((size_t)(0))), &ajla_error , "./ipret-1.inc" ":" "1542"))));
 if (!return_values) {
  mem_free_position(arguments , "./ipret-1.inc" ":" "1544");
  goto call_allocation_error_1;
 }

 for (i = 0; i < n_arguments; i++) {
  frame_t src_slot = ((uintptr_t)(ip)[0]);
  unsigned char src_flag = (unsigned char)((uintptr_t)(ip)[1]);
  arguments[i].f_arg = ((void*)0);
  arguments[i].slot = src_slot;
  arguments[i].deref = (src_flag & 0x0002) != 0;
  (ip += ((2)));
 }

 for (i = 0; i < n_return_values; i++) {
  frame_t slot_r = get_unaligned_32(&(ip)[(0) * 2]);
  return_values[i] = slot_r;
  (ip += (((1) * 2) + 1));
 }

 ex = u_ipret_call_cache(fp, orig_ip, direct_function, arguments, return_values, ((frame_t)-1));
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0))) {
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_SAVE1: do {

 goto call_cache_1;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_INDIRECT_CACHE1: do {

 struct ipret_call_cache_arg *arguments;
 frame_t *return_values;
 void *ex;

 frame_t fn_ref_slot;
 _Bool deref;
 pointer_t *ptr;
 arg_t n_curried_arguments;

call_indirect_cache_1:
 orig_ip = ip;
 n_arguments = ((uintptr_t)(ip + 1)[0]);
 n_return_values = ((uintptr_t)(ip + 1)[1]);
 fn_ref_slot = ((uintptr_t)(ip + 1)[2]);
 deref = (((uintptr_t)(ip + 1)[3]) & 0x0002) != 0;
 (ip += (1 + (4)));

 n_curried_arguments = 0;
 ptr = (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(fn_ref_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
 while (1) {
  do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(ptr); else p_ = *(ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (function) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1605"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(ptr, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(ptr) , "./ipret-1.inc" ":" "1605"); { function_error = thunk_; thunk_reference(function_error); if (deref) frame_free_and_clear(fp, fn_ref_slot); goto call_set_error_1; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, orig_ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);







  n_curried_arguments += ((((void)(zero_()))), &(function)->u_.function_reference)->n_curried_arguments;
  if (!((((void)(zero_()))), &(function)->u_.function_reference)->is_indirect)
   break;
  ptr = &((((void)(zero_()))), &(function)->u_.function_reference)->u.indirect;
 }
 ptr = ((((void)(zero_()))), &(function)->u_.function_reference)->u.direct;
 do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(ptr); else p_ = *(ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (function) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1619"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(ptr, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(ptr) , "./ipret-1.inc" ":" "1619"); { function_error = thunk_; thunk_reference(function_error); if (deref) frame_free_and_clear(fp, fn_ref_slot); goto call_set_error_1; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, orig_ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);
# 1621 "./ipret-1.inc"
 arguments = ((__builtin_expect((int)(!mem_check_overflow(0, n_curried_arguments + n_arguments, sizeof(struct ipret_call_cache_arg), &ajla_error)), 0)) ? ((struct ipret_call_cache_arg *)(void *)(((void*)0))) : ((struct ipret_call_cache_arg *)(void *)(mem_alloc_position((((size_t)(0) + (size_t)(n_curried_arguments + n_arguments) * (size_t)(sizeof(struct ipret_call_cache_arg))) >= ((size_t)(0)) + (zero_()) ? ((size_t)(0) + (size_t)(n_curried_arguments + n_arguments) * (size_t)(sizeof(struct ipret_call_cache_arg))) : ((size_t)(0))), &ajla_error , "./ipret-1.inc" ":" "1621"))));
 if (!arguments) {
  if (deref)
   frame_free_and_clear(fp, fn_ref_slot);
  goto call_allocation_error_1;
 }
 return_values = ((__builtin_expect((int)(!mem_check_overflow(0, n_return_values, sizeof(frame_t), &ajla_error)), 0)) ? ((frame_t *)(void *)(((void*)0))) : ((frame_t *)(void *)(mem_alloc_position((((size_t)(0) + (size_t)(n_return_values) * (size_t)(sizeof(frame_t))) >= ((size_t)(0)) + (zero_()) ? ((size_t)(0) + (size_t)(n_return_values) * (size_t)(sizeof(frame_t))) : ((size_t)(0))), &ajla_error , "./ipret-1.inc" ":" "1627"))));
 if (!return_values) {
  mem_free_position(arguments , "./ipret-1.inc" ":" "1629");
  if (deref)
   frame_free_and_clear(fp, fn_ref_slot);
  goto call_allocation_error_1;
 }

 i = n_curried_arguments;
 function = pointer_get_data_(*(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(fn_ref_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) , "./ipret-1.inc" ":" "1636");
 while (1) {
  arg_t j;
  j = ((((void)(zero_()))), &(function)->u_.function_reference)->n_curried_arguments;
  while (j--) {
   i--;
   arguments[i].f_arg = &((((void)(zero_()))), &(function)->u_.function_reference)->arguments[j];
   arguments[i].deref = 0;
  }
  if (!((((void)(zero_()))), &(function)->u_.function_reference)->is_indirect)
   break;
  function = pointer_get_data_(((((void)(zero_()))), &(function)->u_.function_reference)->u.indirect , "./ipret-1.inc" ":" "1647");
 }

 for (i = n_curried_arguments; i < n_curried_arguments + n_arguments; i++) {
  frame_t src_slot = ((uintptr_t)(ip)[0]);
  unsigned char src_flag = (unsigned char)((uintptr_t)(ip)[1]);
  arguments[i].f_arg = ((void*)0);
  arguments[i].slot = src_slot;
  arguments[i].deref = (src_flag & 0x0002) != 0;
  (ip += ((2)));
 }

 for (i = 0; i < n_return_values; i++) {
  frame_t slot_r = get_unaligned_32(&(ip)[(0) * 2]);
  return_values[i] = slot_r;
  (ip += (((1) * 2) + 1));
 }

 ex = u_ipret_call_cache(fp, orig_ip, ptr, arguments, return_values, deref ? fn_ref_slot : ((frame_t)-1));
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0))) {
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_INDIRECT_SAVE1: do {

 goto call_indirect_cache_1;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

}

label_OPCODE_RETURN1: do {

 struct data *function;
 frame_s *previous_fp;
 const code_t *previous_ip;
 arg_t i, n;



 function = (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function;
 previous_fp = frame_up(fp);
 if ((__builtin_expect((int)(frame_is_top(previous_fp)), 0))) {
  struct execution_control *ex;
  void *exx;
  struct thunk *t;
  struct stack_bottom *sb = frame_stack_bottom(previous_fp);
  ex = sb->ex;
  if (!ex) {
   frame_t src_slot = ((uintptr_t)(ip + 1)[0]);
   sb->ret = u_ipret_copy_variable_to_pointer(fp, src_slot, 1);
   goto exit_ipret;
  }
  t = ex->thunk;
  n = ((((void)(zero_()))), &(function)->u_.function)->n_return_values;
  i = 0;
  do {
   frame_t src_slot = ((uintptr_t)(ip + 1)[i * 2]);
   frame_t flags = ((uintptr_t)(ip + 1)[i * 2 + 1]);
   t->u.function_call.results[i].ptr = u_ipret_copy_variable_to_pointer(fp, src_slot, (flags & 0x0002) != 0);
  } while (++i < n);
  exx = u_thunk_terminate(t, n);





  do { if ((exx) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((exx)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((exx)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 }

 (((struct frame_struct *)(void *)(((const char *)(void *)(previous_fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->timestamp = (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->timestamp;
 previous_ip = &((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(previous_fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code[(((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->previous_ip];

 n = ((((void)(zero_()))), &(function)->u_.function)->n_return_values;
 i = 0;
 do {
  frame_t src_slot, dst_slot, flags;
  src_slot = ((uintptr_t)(ip + 1)[i * 2]);
  flags = ((uintptr_t)(ip + 1)[i * 2 + 1]);
  dst_slot = (frame_t)get_unaligned_32(&(previous_ip)[(0) * 2]);
  previous_ip += ((1) * 2) + 1;
  u_ipret_copy_variable(fp, src_slot, previous_fp, dst_slot, (flags & 0x0002) != 0);
 } while (++i < n);

 fp = previous_fp;
 ip = previous_ip;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


label_OPCODE_STRUCTURED1: do {

 const code_t *orig_ip = ip;

 frame_t struc, elem;
 pointer_t *struc_ptr;
 unsigned char *struc_flat;
 const struct type *t;
 _Bool optimize_elem_is_flat;

 unsigned char type;
 frame_t arg;

 pointer_t thunk_ptr;

 elem = ((uintptr_t)(ip + 1)[1]);
 optimize_elem_is_flat = frame_variable_is_flat(fp, elem);

structured_retry_1:
 struc = ((uintptr_t)(ip + 1)[0]);
 (ip += (1 + (2)));

 t = frame_get_type_of_local(fp, struc);
 if (frame_variable_is_flat(fp, struc)) {
  if (!optimize_elem_is_flat) {
   frame_set_pointer(fp, struc, u_flat_to_data(frame_get_type_of_local(fp, struc), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(struc) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))));
   struc_flat = ((void*)0);
   struc_ptr = (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(struc) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
  } else {
   struc_flat = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(struc) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))));
   struc_ptr = ((void*)0);
  }
 } else {
  struc_flat = ((void*)0);
  struc_ptr = (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(struc) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
 }

 do {
  array_index_t array_index = (((uint64_t)(-((uint64_t)1 << (8 * sizeof(uint64_t) - 2)) * 2)));
  struct data *data = ((void*)0);

  type = (unsigned char)((uintptr_t)(ip)[0]);
  arg = ((uintptr_t)(ip)[1]);
  (ip += ((3)));

  if ((type & 0x0f) == 0x03) {
   void *ex = u_ipret_get_index(fp, orig_ip, fp, arg, ((void*)0), &array_index, &thunk_ptr , "./ipret-1.inc" ":" "1786");
   if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0))) {
    if (ex == ((void *)(uintptr_t)2))
     goto structured_error_1;
    do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
   }
  }

  if (struc_flat) {
   switch (type & 0x0f) {
    case 0x01: {
     const struct flat_record_definition_entry *e;
     ((void)(zero_()));
     e = &(((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1799", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->entries[arg];
     t = e->subtype;
     struc_flat += e->flat_offset;
     break;
    }
    case 0x02: {
     thunk_ptr = u_pointer_error(error_ajla_aux_(1, 10, 0 , "./ipret-1.inc" ":" "1805"), fp, ip , "./ipret-1.inc" ":" "1805");
     goto structured_error_1;
    }
    case 0x03: {
     if ((__builtin_expect((int)(index_ge_int_(array_index, (((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 4)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1809", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 4))), ((void)sizeof(&(((struct flat_array_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_array_definition, type)))))->type == (t)), (((struct flat_array_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_array_definition, type)))))))->n_elements , "./ipret-1.inc" ":" "1809")), 0))) {
      index_free_(&array_index , "./ipret-1.inc" ":" "1810");
      thunk_ptr = u_pointer_error(error_ajla_aux_(1, 9, 0 , "./ipret-1.inc" ":" "1811"), fp, ip , "./ipret-1.inc" ":" "1811");
      goto structured_error_1;
     }
     t = (((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 4)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1814", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 4))), ((void)sizeof(&(((struct flat_array_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_array_definition, type)))))->type == (t)), (((struct flat_array_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_array_definition, type)))))))->base;
     struc_flat += t->size * index_to_int_(array_index , "./ipret-1.inc" ":" "1815");
     index_free_(&array_index , "./ipret-1.inc" ":" "1816");
     break;
    }
    default:
     internal("./ipret-1.inc" ":" "1820", "structured flat: invalid structure type %02x", type);
   }
  } else {
structured_restart_pointer_follow_1:
   do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(struc_ptr); else p_ = *(struc_ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (data) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1831"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(struc_ptr, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(struc_ptr) , "./ipret-1.inc" ":" "1831"); { if ((type & 0x0f) == 0x03) index_free_(&array_index , "./ipret-1.inc" ":" "1829"); goto structured_read_to_the_end_1;; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, orig_ip); } { if ((type & 0x0f) == 0x03) index_free_(&array_index , "./ipret-1.inc" ":" "1826"); do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);







   if ((__builtin_expect((int)(!data_is_writable(data)), 0))) {
    u_struct_clone(struc_ptr);
    goto structured_restart_pointer_follow_1;
   }
   switch (type & 0x0f) {
    case 0x01: {
     const struct record_definition *def = (((__builtin_expect((int)((((((void)(zero_()))), &(data)->u_.record)->definition)->tag == ((((0 + 2 * 5) + 5) + 4) + 2)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1838", "type_def: invalid type tag %u, expected %u", (((((void)(zero_()))), &(data)->u_.record)->definition)->tag, ((((0 + 2 * 5) + 5) + 4) + 2))), ((void)sizeof(&(((struct record_definition *)(void *)((((char *)(void *)((((((void)(zero_()))), &(data)->u_.record)->definition))) - __builtin_offsetof(struct record_definition, type)))))->type == (((((void)(zero_()))), &(data)->u_.record)->definition)), (((struct record_definition *)(void *)((((char *)(void *)((((((void)(zero_()))), &(data)->u_.record)->definition))) - __builtin_offsetof(struct record_definition, type)))))));
     ((void)(zero_()));
     t = def->types[arg];
     struc_ptr = (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(da_record_frame(data)))) + ((size_t)(arg) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));

     if (type & 0x20) {
      if (frame_variable_is_flat(fp, elem)) {
       if (((((((void)(zero_())), ((t)->tag) < 0 + 2 * 5) || (((void)(zero_())), ((t)->tag) >= ((0 + 2 * 5) + 5) && ((t)->tag) < ((0 + 2 * 5) + 5) + 4) || (((void)(zero_())), ((t)->tag) >= (0 + 2 * 5) && ((t)->tag) < (0 + 2 * 5) + 5) || ((t)->tag) == ((((0 + 2 * 5) + 5) + 4) + 0)) || ((t)->tag) == ((((0 + 2 * 5) + 5) + 4) + 3) || ((t)->tag) == ((((0 + 2 * 5) + 5) + 4) + 4)))) {
        frame_free(da_record_frame(data), arg);
        struc_flat = (((unsigned char *)(void *)(((((unsigned char *)(void *)(da_record_frame(data)))) + ((size_t)(arg) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))));
        goto structured_write_flat_1;
       }
      } else {
       if (!frame_test_and_set_flag(da_record_frame(data), arg))
        goto structured_write_ptr_1;
      }
     }

     if (!frame_test_flag(da_record_frame(data), arg)) {
      struc_flat = (((unsigned char *)(void *)(((((unsigned char *)(void *)(da_record_frame(data)))) + ((size_t)(arg) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))));
      if ((__builtin_expect((int)(!optimize_elem_is_flat), 0))) {
       frame_set_pointer(da_record_frame(data), arg, u_flat_to_data(t, struc_flat));
       struc_flat = ((void*)0);
      }
     }
     break;
    }
    case 0x02: {
     if ((__builtin_expect((int)(((((void)(zero_()))), &(data)->u_.option)->option != arg), 0))) {
      if ((__builtin_expect((int)((type & 0x20) != 0), 1))) {
       ((((void)(zero_()))), &(data)->u_.option)->option = arg;
      } else {
       thunk_ptr = u_pointer_error(error_ajla_aux_(1, 10, 0 , "./ipret-1.inc" ":" "1870"), fp, ip , "./ipret-1.inc" ":" "1870");
structured_error_1:
       if (struc_flat) {
        u_pointer_dereference_(thunk_ptr , "./ipret-1.inc" ":" "1873");
        optimize_elem_is_flat = 0;
        ip = orig_ip;
        goto structured_retry_1;
       } else {
        u_pointer_dereference_(*struc_ptr , "./ipret-1.inc" ":" "1878");
        *struc_ptr = thunk_ptr;
        goto structured_read_to_the_end_1;
       }
      }
     }
     struc_ptr = &((((void)(zero_()))), &(data)->u_.option)->pointer;
     break;
    }
    case 0x03: {
     unsigned array_flags;
     if ((__builtin_expect((int)((((void)(zero_())), (refcount_tag_get((const refcount_t *)&(data)->refcount_))) == 10), 0))) {
      array_index_t len_first;

      if (u_array_incomplete_collapse(struc_ptr))
       goto structured_restart_pointer_follow_1;

      len_first = u_array_len(pointer_get_data_(((((void)(zero_()))), &(data)->u_.array_incomplete)->first , "./ipret-1.inc" ":" "1895"));
      if (!index_ge_index_(array_index, len_first , "./ipret-1.inc" ":" "1896")) {
       index_free_(&len_first , "./ipret-1.inc" ":" "1897");
       struc_ptr = &((((void)(zero_()))), &(data)->u_.array_incomplete)->first;
       goto structured_restart_pointer_follow_1;
      } else {
       index_sub_(&array_index, len_first , "./ipret-1.inc" ":" "1901");
       index_free_(&len_first , "./ipret-1.inc" ":" "1902");
       struc_ptr = &((((void)(zero_()))), &(data)->u_.array_incomplete)->next;
       goto structured_restart_pointer_follow_1;
      }
     }
     if (!optimize_elem_is_flat) {
      array_flags = 2;
     } else if (type & 0x20) {
      array_flags = 1;
      t = frame_get_type_of_local(fp, elem);
     } else {
      array_flags = 0;
     }
     if ((__builtin_expect((int)(!u_array_modify(struc_ptr, array_index, array_flags, &struc_ptr, &struc_flat, &t, fp, ip)), 0))) {
      goto structured_read_to_the_end_1;
     }
     break;
    }
    default:
     internal("./ipret-1.inc" ":" "1921", "structured: invalid structure type %02x", type);
   }
  }
 } while (!(type & 0x20));
 if (struc_flat) {
structured_write_flat_1:
  memcpy_fast(struc_flat, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(elem) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), frame_get_type_of_local(fp, elem)->size);
 } else {

  if ((__builtin_expect((int)(!pointer_is_empty(*struc_ptr)), 1)))
   u_pointer_dereference_(*struc_ptr , "./ipret-1.inc" ":" "1931");
  if (frame_variable_is_flat(fp, elem)) {
   *struc_ptr = u_flat_to_data(frame_get_type_of_local(fp, elem), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(elem) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))));
  } else {
structured_write_ptr_1:
   *struc_ptr = frame_get_pointer_reference(fp, elem, (type & 0x10) != 0);
  }
 }
 if (0) {
  do {
   type = (unsigned char)((uintptr_t)(ip)[0]);
   arg = ((uintptr_t)(ip)[1]);
   (ip += ((3)));
structured_read_to_the_end_1:;
  } while (!(type & 0x20));
  if (type & 0x10)
   frame_free(fp, elem);
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_RECORD_CREATE1: do {

 frame_t result_slot;
 arg_t n_entries, i, ii;
 const struct type *t;
 const struct record_definition *def;

 result_slot = ((uintptr_t)(ip + 1)[0]);
 n_entries = ((uintptr_t)(ip + 1)[1]);
 (ip += (1 + (2)));

 t = frame_get_type_of_local(fp, result_slot);
 if (t->tag == ((((0 + 2 * 5) + 5) + 4) + 3)) {
  const code_t *backup_ip;
  def = (((__builtin_expect((int)(((((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1966", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->base)->tag == ((((0 + 2 * 5) + 5) + 4) + 2)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1966", "type_def: invalid type tag %u, expected %u", ((((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1966", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->base)->tag, ((((0 + 2 * 5) + 5) + 4) + 2))), ((void)sizeof(&(((struct record_definition *)(void *)((((char *)(void *)(((((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1966", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->base))) - __builtin_offsetof(struct record_definition, type)))))->type == ((((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1966", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->base)), (((struct record_definition *)(void *)((((char *)(void *)(((((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1966", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->base))) - __builtin_offsetof(struct record_definition, type)))))));
  backup_ip = ip;
  for (i = 0, ii = 0; i < n_entries; i++, ii++) {
   frame_t var_slot, record_slot;
   flat_size_t flat_offset;
   const struct type *flat_type;

   while ((__builtin_expect((int)(record_definition_is_elided(def, ii)), 0)))
    ii++;

   var_slot = ((uintptr_t)(ip)[0]);

   if ((__builtin_expect((int)(!frame_variable_is_flat(fp, var_slot)), 0))) {
    ip = backup_ip;
    goto create_record_no_flat_1;
   }
   record_slot = record_definition_slot(def, ii);
   flat_offset = (((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1983", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->entries[record_slot].flat_offset;
   flat_type = (((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1984", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->entries[record_slot].subtype;
   ((void)(zero_()));
   memcpy_fast((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(result_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))) + flat_offset, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(var_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), flat_type->size);
   (ip += ((2)));
  }
  ((void)(zero_()));
 } else {
  struct data *result;
  def = (((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 2)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1992", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 2))), ((void)sizeof(&(((struct record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct record_definition, type)))))->type == (t)), (((struct record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct record_definition, type)))))));
create_record_no_flat_1:
  result = u_data_alloc_record_mayfail(def, &ajla_error , "./ipret-1.inc" ":" "1994");
  if ((__builtin_expect((int)(!result), 0))) {
   ip = free_parameters_1(fp, ip, n_entries);
   frame_set_pointer(fp, result_slot, u_pointer_error(ajla_error, fp, ip , "./ipret-1.inc" ":" "1997"));
   break;
  }
  memset(da_record_frame(result), 0, (((((frame_t)(def->n_slots)) + (1 << (( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((1 << (( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * ((frame_t)(def->n_slots)))) >> (( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) * ((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))));
  for (i = 0, ii = 0; i < n_entries; i++, ii++) {
   frame_t var_slot, record_slot;
   const struct type *rec_type, *var_type;

   while ((__builtin_expect((int)(record_definition_is_elided(def, ii)), 0)))
    ii++;

   var_slot = ((uintptr_t)(ip)[0]);
   record_slot = record_definition_slot(def, ii);
   rec_type = def->types[record_slot];
   var_type = frame_get_type_of_local(fp, var_slot);

   if (!frame_variable_is_flat(fp, var_slot)) {
    pointer_t ptr = frame_get_pointer_reference(fp, var_slot, (((uintptr_t)(ip)[1]) & 0x0002) != 0);
    frame_set_pointer(da_record_frame(result), record_slot, ptr);
   } else if (((((((void)(zero_())), ((rec_type)->tag) < 0 + 2 * 5) || (((void)(zero_())), ((rec_type)->tag) >= ((0 + 2 * 5) + 5) && ((rec_type)->tag) < ((0 + 2 * 5) + 5) + 4) || (((void)(zero_())), ((rec_type)->tag) >= (0 + 2 * 5) && ((rec_type)->tag) < (0 + 2 * 5) + 5) || ((rec_type)->tag) == ((((0 + 2 * 5) + 5) + 4) + 0)) || ((rec_type)->tag) == ((((0 + 2 * 5) + 5) + 4) + 3) || ((rec_type)->tag) == ((((0 + 2 * 5) + 5) + 4) + 4)))) {
    ((void)(zero_()));
    memcpy_fast((((unsigned char *)(void *)(((((unsigned char *)(void *)(da_record_frame(result)))) + ((size_t)(record_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(var_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), rec_type->size);
   } else {
    pointer_t ptr = u_flat_to_data(var_type, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(var_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))));
    frame_set_pointer(da_record_frame(result), record_slot, ptr);
   }

   (ip += ((2)));
  }
  frame_set_pointer(fp, result_slot, pointer_data(result));
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_RECORD_LOAD1: do {

 frame_t record, record_slot, result;
 unsigned flags;
 const struct type *t;
 record = ((uintptr_t)(ip + 1)[0]);
 record_slot = ((uintptr_t)(ip + 1)[1]);
 result = ((uintptr_t)(ip + 1)[2]);
 flags = ((uintptr_t)(ip + 1)[3]);

 t = frame_get_type_of_local(fp, record);
 if (t->tag == ((((0 + 2 * 5) + 5) + 4) + 3) && !frame_test_flag(fp, record)) {
  const struct flat_record_definition_entry *ft = &(((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "2043", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->entries[record_slot];
  if ((__builtin_expect((int)(((((((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) < 0 + 2 * 5) || (((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) >= ((0 + 2 * 5) + 5) && ((frame_get_type_of_local(fp, result))->tag) < ((0 + 2 * 5) + 5) + 4) || (((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) >= (0 + 2 * 5) && ((frame_get_type_of_local(fp, result))->tag) < (0 + 2 * 5) + 5) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 0)) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 3) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 4)))), 1))) {
   memcpy_fast((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(result) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(record) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))) + ft->flat_offset, ft->subtype->size);
  } else {
   pointer_t ptr = u_flat_to_data(ft->subtype, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(record) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))) + ft->flat_offset);
   frame_set_pointer(fp, result, ptr);
  }
 } else {
  const struct type *rtype, *etype;
  struct data *data;
  frame_s *fr;
  do { pointer_t p_; if (!(1)) p_ = pointer_locked_read((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(record) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); else p_ = *((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(record) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (data) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "2064"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(record) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), ((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) >= 0 ? &frame_execution_control(fp)->wait[((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) & 1] : ((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(record) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))) , "./ipret-1.inc" ":" "2064"); { thunk_reference(thunk_); frame_set_pointer(fp, result, pointer_thunk(thunk_)); goto record_load_end_1;; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) >= 0 && !(((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) & 2)) { u_pointer_follow_wait(fp, ip); } { if (!(flags & 0x0001)) { ex_ = u_ipret_record_load_create_thunk(fp, ip, record, record_slot, result); if (ex_ == ((void *)(uintptr_t)3)) goto record_load_end_1; } do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);
# 2065 "./ipret-1.inc"
  rtype = ((((void)(zero_()))), &(data)->u_.record)->definition;
  etype = (((__builtin_expect((int)((rtype)->tag == ((((0 + 2 * 5) + 5) + 4) + 2)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "2066", "type_def: invalid type tag %u, expected %u", (rtype)->tag, ((((0 + 2 * 5) + 5) + 4) + 2))), ((void)sizeof(&(((struct record_definition *)(void *)((((char *)(void *)((rtype))) - __builtin_offsetof(struct record_definition, type)))))->type == (rtype)), (((struct record_definition *)(void *)((((char *)(void *)((rtype))) - __builtin_offsetof(struct record_definition, type)))))))->types[record_slot];
  fr = da_record_frame(data);
  if (!frame_test_flag(fr, record_slot)) {
    if ((__builtin_expect((int)(((((((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) < 0 + 2 * 5) || (((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) >= ((0 + 2 * 5) + 5) && ((frame_get_type_of_local(fp, result))->tag) < ((0 + 2 * 5) + 5) + 4) || (((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) >= (0 + 2 * 5) && ((frame_get_type_of_local(fp, result))->tag) < (0 + 2 * 5) + 5) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 0)) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 3) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 4)))), 1))) {
    memcpy_fast((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(result) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fr))) + ((size_t)(record_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), etype->size);
    } else {
    pointer_t ptr = u_flat_to_data(etype, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fr))) + ((size_t)(record_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))));
    frame_set_pointer(fp, result, ptr);
    }
  } else {
   u_pointer_reference_maybe_(fp, result, (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fr))) + ((size_t)(record_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), flags , "./ipret-1.inc" ":" "2076");
  }
 }

record_load_end_1:
 (ip += (1 + (4)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_OPTION_CREATE_EMPTY_FLAT1: do {

 frame_t slot_r = ((uintptr_t)(ip + 1)[0]);
 ajla_flat_option_t opt = (ajla_flat_option_t)((uintptr_t)(ip + 1)[1]);
 ((void)(zero_()));
 __asm__ volatile ("":::"memory");
 *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = opt;
 __asm__ volatile ("":::"memory");
 (ip += (1 + (2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_OPTION_CREATE_EMPTY1: do {

 struct data *d;
 frame_t slot_r;

 d = data_init_(((struct data *)(void *)(ptrcomp_verify(((void *)(void *)(mem_align_position((__builtin_offsetof(struct data, u_.option) + sizeof(((struct data *)((void*)0))->u_.option)), (((((uintptr_t)1 << 0) * 2)) >= (1) ? ((((uintptr_t)1 << 0) * 2)) : (1)), &ajla_error , "./ipret-1.inc" ":" "2102")))))), 4);
 slot_r = ((uintptr_t)(ip + 1)[0]);
 if ((__builtin_expect((int)(d != ((void*)0)), 1))) {
  ((((void)(zero_()))), &(d)->u_.option)->option = ((uintptr_t)(ip + 1)[1]);
  ((((void)(zero_()))), &(d)->u_.option)->pointer = pointer_empty();
  frame_set_pointer(fp, slot_r, pointer_data(d));
 } else {
  frame_set_pointer(fp, slot_r, u_pointer_error(ajla_error, fp, ip , "./ipret-1.inc" ":" "2109"));
 }
 (ip += (1 + (2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_OPTION_CREATE1: do {

 struct data *d;
 frame_t slot_1, slot_r;
 pointer_t ptr;

 slot_1 = ((uintptr_t)(ip + 1)[2]);
 if (!frame_variable_is_flat(fp, slot_1)) {
  ptr = frame_get_pointer_reference(fp, slot_1, (((uintptr_t)(ip + 1)[3]) & 0x0002) != 0);
 } else {
  ptr = u_flat_to_data(frame_get_type_of_local(fp, slot_1), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))));
 }

 d = data_init_(((struct data *)(void *)(ptrcomp_verify(((void *)(void *)(mem_align_position((__builtin_offsetof(struct data, u_.option) + sizeof(((struct data *)((void*)0))->u_.option)), (((((uintptr_t)1 << 0) * 2)) >= (1) ? ((((uintptr_t)1 << 0) * 2)) : (1)), &ajla_error , "./ipret-1.inc" ":" "2128")))))), 4);
 slot_r = ((uintptr_t)(ip + 1)[0]);
 if ((__builtin_expect((int)(d != ((void*)0)), 1))) {
  ((((void)(zero_()))), &(d)->u_.option)->option = ((uintptr_t)(ip + 1)[1]);
  ((((void)(zero_()))), &(d)->u_.option)->pointer = ptr;
  frame_set_pointer(fp, slot_r, pointer_data(d));
 } else {
  u_pointer_dereference_(ptr , "./ipret-1.inc" ":" "2135");
  frame_set_pointer(fp, slot_r, u_pointer_error(ajla_error, fp, ip , "./ipret-1.inc" ":" "2136"));
 }
 (ip += (1 + (4)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_OPTION_LOAD1: do {

 frame_t option, option_idx, result;
 unsigned flags;
 struct data *data;
 pointer_t ptr;

 option = ((uintptr_t)(ip + 1)[0]);
 option_idx = ((uintptr_t)(ip + 1)[1]);
 result = ((uintptr_t)(ip + 1)[2]);
 flags = ((uintptr_t)(ip + 1)[3]);

 if ((__builtin_expect((int)(frame_variable_is_flat(fp, option)), 0)))
  goto option_load_mismatch1;

 do { pointer_t p_; if (!(1)) p_ = pointer_locked_read((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(option) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); else p_ = *((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(option) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (data) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "2167"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(option) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), ((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) >= 0 ? &frame_execution_control(fp)->wait[((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) & 1] : ((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(option) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))) , "./ipret-1.inc" ":" "2167"); { thunk_reference(thunk_); frame_set_pointer(fp, result, pointer_thunk(thunk_)); goto option_load_end_1;; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) >= 0 && !(((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) & 2)) { u_pointer_follow_wait(fp, ip); } { if (!(flags & 0x0001)) { ex_ = u_ipret_option_load_create_thunk(fp, ip, option, option_idx, result); if (ex_ == ((void *)(uintptr_t)3)) goto option_load_end_1; } do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);
# 2169 "./ipret-1.inc"
 if ((__builtin_expect((int)(((((void)(zero_()))), &(data)->u_.option)->option != option_idx), 0))) {
option_load_mismatch1:
  ptr = u_pointer_error(error_ajla_aux_(1, 10, 0 , "./ipret-1.inc" ":" "2171"), fp, ip , "./ipret-1.inc" ":" "2171");
  frame_set_pointer(fp, result, ptr);
 } else {
  u_pointer_reference_maybe_(fp, result, &((((void)(zero_()))), &(data)->u_.option)->pointer, flags , "./ipret-1.inc" ":" "2174");
 }

option_load_end_1:
 (ip += (1 + (4)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


{ frame_t slot_1; ajla_option_t option;




label_OPCODE_OPTION_TEST_FLAT1: do {

 slot_1 = ((uintptr_t)(ip + 1)[0]);

 if (!frame_test_flag(fp, slot_1)) {
  __asm__ volatile ("":::"memory");
  option = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
  __asm__ volatile ("":::"memory");
  goto option_test_store_result_1;
 }
 goto option_test_1;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_OPTION_TEST1: do {

 frame_t slot_r;
 pointer_t ptr;
 struct data *data;

 slot_1 = ((uintptr_t)(ip + 1)[0]);
option_test_1:
 ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
 if ((__builtin_expect((int)(pointer_is_thunk(ptr)), 0))) {
  void *ex;
  ((void)(zero_()));
  ex = u_thunk_option_test(fp, ip, slot_1, ((uintptr_t)(ip + 1)[1]), ((uintptr_t)(ip + 1)[2]));
  if (ex == ((void *)(uintptr_t)3)) {
   (ip += (1 + (3)));
   break;
  } else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) {
   do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
  }
  break;
 }
 data = pointer_get_data_(ptr , "./ipret-1.inc" ":" "2223");
 option = ((((void)(zero_()))), &(data)->u_.option)->option;
option_test_store_result_1:
 slot_r = ((uintptr_t)(ip + 1)[2]);
 __asm__ volatile ("":::"memory");
 ((void)(zero_()));
 *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = option == (ajla_option_t)((uintptr_t)(ip + 1)[1]);
 __asm__ volatile ("":::"memory");
 (ip += (1 + (3)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_OPTION_ORD_FLAT1: do {

 slot_1 = ((uintptr_t)(ip + 1)[0]);

 if (!frame_test_flag(fp, slot_1)) {
  __asm__ volatile ("":::"memory");
  option = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
  __asm__ volatile ("":::"memory");
  goto option_ord_store_result_1;
 }
 goto option_ord_1;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_OPTION_ORD1: do {

 frame_t slot_r;
 pointer_t ptr;
 struct data *data;

 slot_1 = ((uintptr_t)(ip + 1)[0]);
option_ord_1:
 ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
 if ((__builtin_expect((int)(pointer_is_thunk(ptr)), 0))) {
  void *ex;
  ((void)(zero_()));
  ex = u_thunk_option_ord(fp, ip, slot_1, ((uintptr_t)(ip + 1)[1]));
  if (ex == ((void *)(uintptr_t)3)) {
   (ip += (1 + (2)));
   break;
  } else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) {
   do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
  }
  break;
 }
 data = pointer_get_data_(ptr , "./ipret-1.inc" ":" "2270");
 option = ((((void)(zero_()))), &(data)->u_.option)->option;
option_ord_store_result_1:
 slot_r = ((uintptr_t)(ip + 1)[1]);
 __asm__ volatile ("":::"memory");
 ((void)(zero_()));
 *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = option;
 __asm__ volatile ("":::"memory");
 (ip += (1 + (2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

}


label_OPCODE_ARRAY_CREATE1: do {

 frame_t result_slot;
 size_t n_entries;
 struct data *total;

 result_slot = ((uintptr_t)(ip + 1)[0]);
 n_entries = ((uintptr_t)(ip + 1)[1]);
 (ip += (1 + (2)));

 ((void)(zero_()));

 total = ((void*)0);
 while (1) {
  size_t n, i;
  struct data *a;
  const struct type *type = frame_get_type_of_local(fp, ((uintptr_t)(ip)[0]));
  _Bool flat = frame_variable_is_flat(fp, ((uintptr_t)(ip)[0]));
  for (n = 1; n < n_entries; n++) {
   if (frame_variable_is_flat(fp, ((uintptr_t)(ip)[n * 2])) != flat)
    break;
   if ((__builtin_expect((int)((int64_t)(n + 1) < (zero_())), 0)))
    break;
  }
  do {
   if (flat)
    a = u_data_alloc_array_flat_mayfail(type, n, n, 0, &ajla_error , "./ipret-1.inc" ":" "2311");
   else
    a = u_data_alloc_array_pointers_mayfail(n, n, &ajla_error , "./ipret-1.inc" ":" "2313");
  } while ((__builtin_expect((int)(!a), 0)) && (n >>= 1));
  if ((__builtin_expect((int)(!a), 0))) {
   if (total)
    data_dereference(total);
   goto array_create_error_1;
  }
  n_entries -= n;
  if (flat) {
   unsigned char *flat_ptr = da_array_flat(a);
   for (i = 0; i < n; i++) {
    frame_t var_slot = ((uintptr_t)(ip)[0]);
    memcpy_fast(flat_ptr, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(var_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), type->size);
    flat_ptr += type->size;
    (ip += ((2)));
   }
  } else {
   for (i = 0; i < n; i++) {
    frame_t var_slot = ((uintptr_t)(ip)[0]);
    pointer_t ptr = frame_get_pointer_reference(fp, var_slot, (((uintptr_t)(ip)[1]) & 0x0002) != 0);
    ((((void)(zero_()))), &(a)->u_.array_pointers)->pointer[i] = ptr;
    (ip += ((2)));
   }
  }
  if ((__builtin_expect((int)(!total), 1))) {
   total = a;
  } else {
   total = u_array_join(total, a, &ajla_error);
   if ((__builtin_expect((int)(!total), 0))) {
array_create_error_1:
    ip = free_parameters_1(fp, ip, n_entries);
    frame_set_pointer(fp, result_slot, u_pointer_error(ajla_error, fp, ip , "./ipret-1.inc" ":" "2344"));
    break;
   }
  }
  if ((__builtin_expect((int)(!n_entries), 1))) {
   frame_set_pointer(fp, result_slot, pointer_data(total));
   break;
  }
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_CREATE_EMPTY_FLAT1: do {

 frame_t result_slot;
 struct data *a;
 const struct type *type = da_type((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function, ((uintptr_t)(ip + 1)[1]));
 ((void)(zero_()));

 a = u_data_alloc_array_flat_mayfail(type, 0, 0, 0, &ajla_error , "./ipret-1.inc" ":" "2363");
 result_slot = ((uintptr_t)(ip + 1)[0]);
 frame_set_pointer(fp, result_slot, (__builtin_expect((int)(a != ((void*)0)), 1)) ? pointer_data(a) : u_pointer_error(ajla_error, fp, ip , "./ipret-1.inc" ":" "2365"));
 (ip += (1 + (2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_CREATE_EMPTY1: do {

 frame_t result_slot;
 struct data *a;

 a = u_data_alloc_array_pointers_mayfail(0, 0, &ajla_error , "./ipret-1.inc" ":" "2375");
 result_slot = ((uintptr_t)(ip + 1)[0]);
 frame_set_pointer(fp, result_slot, (__builtin_expect((int)(a != ((void*)0)), 1)) ? pointer_data(a) : u_pointer_error(ajla_error, fp, ip , "./ipret-1.inc" ":" "2377"));
 (ip += (1 + (1)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_FILL1: do {

 frame_t content_slot, length_slot, result_slot;
 unsigned char content_flag;
 array_index_t length;
 pointer_t result_ptr;
 void *ex;

 content_slot = ((uintptr_t)(ip + 1)[0]);
 content_flag = ((uintptr_t)(ip + 1)[1]);
 length_slot = ((uintptr_t)(ip + 1)[2]);
 result_slot = ((uintptr_t)(ip + 1)[3]);

 ex = u_ipret_get_index(fp, ip, fp, length_slot, ((void*)0), &length, &result_ptr , "./ipret-1.inc" ":" "2395");
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0))) {
  if (ex == ((void *)(uintptr_t)2)) {
   if (content_flag & 0x0002)
    frame_free_and_clear(fp, content_slot);
   goto array_fill_error_1;
  }
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
 }

 if (!frame_variable_is_flat(fp, content_slot)) {
  pointer_t ptr = frame_get_pointer_reference(fp, content_slot, (content_flag & 0x0002) != 0);
  if ((__builtin_expect((int)((content_flag & 0x0004) != 0), 0))) {
   result_ptr = u_array_create_sparse(length, ptr);
  } else {
   result_ptr = u_array_create(length, ((void*)0), ((void*)0), ptr);
  }
 } else {
  const struct type *type = frame_get_type_of_local(fp, content_slot);
  __asm__ volatile ("":::"memory");
  if ((__builtin_expect((int)((content_flag & 0x0004) != 0), 0)) && (__builtin_expect((int)(index_ge_int_(length, 1 , "./ipret-1.inc" ":" "2415")), 1))) {
   pointer_t ptr = u_flat_to_data(type, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(content_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))));
   result_ptr = u_array_create_sparse(length, ptr);
  } else {
   if (((((((void)(zero_())), ((frame_get_type_of_local(fp, result_slot))->tag) < 0 + 2 * 5) || (((void)(zero_())), ((frame_get_type_of_local(fp, result_slot))->tag) >= ((0 + 2 * 5) + 5) && ((frame_get_type_of_local(fp, result_slot))->tag) < ((0 + 2 * 5) + 5) + 4) || (((void)(zero_())), ((frame_get_type_of_local(fp, result_slot))->tag) >= (0 + 2 * 5) && ((frame_get_type_of_local(fp, result_slot))->tag) < (0 + 2 * 5) + 5) || ((frame_get_type_of_local(fp, result_slot))->tag) == ((((0 + 2 * 5) + 5) + 4) + 0)) || ((frame_get_type_of_local(fp, result_slot))->tag) == ((((0 + 2 * 5) + 5) + 4) + 3) || ((frame_get_type_of_local(fp, result_slot))->tag) == ((((0 + 2 * 5) + 5) + 4) + 4)))) {
    unsigned char *result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(result_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))));
    int64_t l = index_to_int_(length , "./ipret-1.inc" ":" "2421");
    index_free_(&length , "./ipret-1.inc" ":" "2422");
    while (l--) {
     result = mempcpy(result, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(content_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), type->size);
    }
    goto array_exit_1;
   } else {
    result_ptr = u_array_create(length, type, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(content_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), pointer_empty());
   }
  }
  __asm__ volatile ("":::"memory");
 }

array_fill_error_1:
 frame_set_pointer(fp, result_slot, result_ptr);

array_exit_1:
 (ip += (1 + (4)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_STRING1: do {

 frame_t result_slot, length;
 pointer_t result_ptr;

 result_slot = ((uintptr_t)(ip + 1)[0]);
 length = ((uintptr_t)(ip + 1)[1]);
 (ip += (1 + (2)));

 if ((__builtin_expect((int)((int64_t)length < (int64_t)(zero_())), 0)) ||
     (__builtin_expect((int)((frame_t)(int64_t)length != length), 0))) {
  result_ptr = u_pointer_error(error_ajla_aux_(2, 3, 0 , "./ipret-1.inc" ":" "2453"), fp, ip , "./ipret-1.inc" ":" "2453");
 } else {
  result_ptr = u_array_string(length, type_get_fixed(0, 1), ((unsigned char *)(void *)(ip)));
 }
 frame_set_pointer(fp, result_slot, result_ptr);

 (ip += ((length + 1) >> 1));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_UNICODE1: do {

 frame_t result_slot, length;
 pointer_t result_ptr;

 result_slot = ((uintptr_t)(ip + 1)[0]);
 length = ((uintptr_t)(ip + 1)[1]);
 (ip += (1 + (2)));

 if ((__builtin_expect((int)((int64_t)length < (int64_t)(zero_())), 0)) ||
     (__builtin_expect((int)((frame_t)(int64_t)length != length), 0))) {
  result_ptr = u_pointer_error(error_ajla_aux_(2, 3, 0 , "./ipret-1.inc" ":" "2474"), fp, ip , "./ipret-1.inc" ":" "2474");
 } else {
  result_ptr = u_array_string(length, type_get_int(2), ((unsigned char *)(void *)(ip)));
 }
 frame_set_pointer(fp, result_slot, result_ptr);

 (ip += (length * 2));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_LOAD1: do {

 frame_t array, idx, result;
 unsigned flags;
 const struct type *t, *t_elem;
 void *ex;
 array_index_t array_index;
 pointer_t ptr;
 unsigned char *flat;

 array = ((uintptr_t)(ip + 1)[0]);
 idx = ((uintptr_t)(ip + 1)[1]);
 result = ((uintptr_t)(ip + 1)[2]);
 flags = ((uintptr_t)(ip + 1)[3]);

 ex = u_ipret_get_index(fp, ip, fp, idx, ((void*)0), &array_index, &ptr , "./ipret-1.inc" ":" "2499");
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0))) {
  if (ex == ((void *)(uintptr_t)2))
   goto array_load_set_ptr_1;
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
 }

 t = frame_get_type_of_local(fp, array);
 if (t->tag == ((((0 + 2 * 5) + 5) + 4) + 4) && !frame_test_flag(fp, array)) {
  const struct flat_array_definition *def = (((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 4)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "2508", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 4))), ((void)sizeof(&(((struct flat_array_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_array_definition, type)))))->type == (t)), (((struct flat_array_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_array_definition, type)))))));
  if ((__builtin_expect((int)(index_ge_int_(array_index, def->n_elements , "./ipret-1.inc" ":" "2509")), 0))) {
   if ((__builtin_expect((int)((flags & 0x0004) != 0), 0)))
    internal("./ipret-1.inc" ":" "2511", "array_load: flat array index out of range");
   index_free_(&array_index , "./ipret-1.inc" ":" "2512");
   ptr = u_pointer_error(error_ajla_aux_(1, 9, 0 , "./ipret-1.inc" ":" "2513"), fp, ip , "./ipret-1.inc" ":" "2513");
   goto array_load_set_ptr_1;
  }
  t_elem = def->base;
  flat = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(array) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))) + t_elem->size * index_to_int_(array_index , "./ipret-1.inc" ":" "2517");
  index_free_(&array_index , "./ipret-1.inc" ":" "2518");
  goto array_load_set_flat_1;
 } else {
  pointer_t *array_ptr = (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(array) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
  pointer_t *pptr;
  struct data *data;

array_restart_pointer_follow_1:
  do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(array_ptr); else p_ = *(array_ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (data) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "2538"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(array_ptr, ((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) >= 0 ? &frame_execution_control(fp)->wait[((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) & 1] : ((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(array_ptr) , "./ipret-1.inc" ":" "2538"); { index_free_(&array_index , "./ipret-1.inc" ":" "2534"); thunk_reference(thunk_); ptr = pointer_thunk(thunk_); goto array_load_set_ptr_1;; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) >= 0 && !(((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) & 2)) { u_pointer_follow_wait(fp, ip); } { index_free_(&array_index , "./ipret-1.inc" ":" "2527"); if (!(flags & 0x0001)) { ex_ = u_ipret_array_load_create_thunk(fp, ip, array, idx, result); if (ex_ == ((void *)(uintptr_t)3)) goto array_load_end_1; } do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);
# 2540 "./ipret-1.inc"
  if ((__builtin_expect((int)((((void)(zero_())), (refcount_tag_get((const refcount_t *)&(data)->refcount_))) == 10), 0))) {
   array_index_t len_first;

   if (array_ptr == (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(array) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))) {
    if (!frame_test_and_set_flag(fp, array))
     data_reference(data);
    if (u_array_incomplete_collapse(array_ptr))
     goto array_restart_pointer_follow_1;
   }

   len_first = u_array_len(pointer_get_data_(((((void)(zero_()))), &(data)->u_.array_incomplete)->first , "./ipret-1.inc" ":" "2550"));
   if (!index_ge_index_(array_index, len_first , "./ipret-1.inc" ":" "2551")) {
    index_free_(&len_first , "./ipret-1.inc" ":" "2552");
    data = pointer_get_data_(((((void)(zero_()))), &(data)->u_.array_incomplete)->first , "./ipret-1.inc" ":" "2553");
   } else {
    index_sub_(&array_index, len_first , "./ipret-1.inc" ":" "2555");
    index_free_(&len_first , "./ipret-1.inc" ":" "2556");
    array_ptr = &((((void)(zero_()))), &(data)->u_.array_incomplete)->next;
    goto array_restart_pointer_follow_1;
   }
  }

  if ((__builtin_expect((int)(!u_array_read(data, array_index, &pptr, &flat, &t_elem, ((void*)0))), 0))) {
   if ((__builtin_expect((int)((flags & 0x0004) != 0), 0)))
    internal("./ipret-1.inc" ":" "2564", "array_load: array index out of range");
   ptr = u_pointer_error(error_ajla_aux_(1, 9, 0 , "./ipret-1.inc" ":" "2565"), fp, ip , "./ipret-1.inc" ":" "2565");
   goto array_load_set_ptr_1;
  }
  if (pptr) {
   u_pointer_reference_maybe_(fp, result, pptr, flags , "./ipret-1.inc" ":" "2569");
   goto array_load_end_1;
  } else {
array_load_set_flat_1:
    if ((__builtin_expect((int)(((((((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) < 0 + 2 * 5) || (((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) >= ((0 + 2 * 5) + 5) && ((frame_get_type_of_local(fp, result))->tag) < ((0 + 2 * 5) + 5) + 4) || (((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) >= (0 + 2 * 5) && ((frame_get_type_of_local(fp, result))->tag) < (0 + 2 * 5) + 5) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 0)) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 3) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 4)))), 1))) {
    memcpy_fast((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(result) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), flat, t_elem->size);
    goto array_load_end_1;
    } else {
    ptr = u_flat_to_data(t_elem, flat);
    }
  }
 }

array_load_set_ptr_1:
 frame_set_pointer(fp, result, ptr);

array_load_end_1:
 (ip += (1 + (4)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_LEN1: do {

 frame_t slot_a, slot_r;
 unsigned flags;
 void *ex;

 slot_a = ((uintptr_t)(ip + 1)[0]);
 slot_r = ((uintptr_t)(ip + 1)[1]);
 flags = ((uintptr_t)(ip + 1)[2]);

 ex = u_ipret_array_len(fp, ip, slot_r, slot_a, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + (3)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_LEN_GREATER_THAN1: do {

 frame_t slot_a, slot_l, slot_r;
 unsigned flags;
 void *ex;

 slot_a = ((uintptr_t)(ip + 1)[0]);
 slot_l = ((uintptr_t)(ip + 1)[1]);
 slot_r = ((uintptr_t)(ip + 1)[2]);
 flags = ((uintptr_t)(ip + 1)[3]);

 ex = u_ipret_array_len_greater_than(fp, ip, slot_r, slot_a, slot_l, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + (4)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_SUB1: do {

 frame_t slot_a, slot_start, slot_end, slot_r;
 unsigned flags;
 void *ex;

 slot_a = ((uintptr_t)(ip + 1)[0]);
 slot_start = ((uintptr_t)(ip + 1)[1]);
 slot_end = ((uintptr_t)(ip + 1)[2]);
 slot_r = ((uintptr_t)(ip + 1)[3]);
 flags = ((uintptr_t)(ip + 1)[4]);

 ex = u_ipret_array_sub(fp, ip, slot_r, slot_a, slot_start, slot_end, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + (5)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_SKIP1: do {

 frame_t slot_a, slot_start, slot_r;
 unsigned flags;
 void *ex;

 slot_a = ((uintptr_t)(ip + 1)[0]);
 slot_start = ((uintptr_t)(ip + 1)[1]);
 slot_r = ((uintptr_t)(ip + 1)[2]);
 flags = ((uintptr_t)(ip + 1)[3]);

 ex = u_ipret_array_skip(fp, ip, slot_r, slot_a, slot_start, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + (4)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_APPEND1: do {

 frame_t slot_r, slot_1, slot_2;
 unsigned flags;
 void *ex;

 slot_r = ((uintptr_t)(ip + 1)[0]);
 flags = ((uintptr_t)(ip + 1)[1]);
 slot_1 = ((uintptr_t)(ip + 1)[2]);
 slot_2 = ((uintptr_t)(ip + 1)[3]);

 ex = u_ipret_array_append(fp, ip, slot_r, slot_1, slot_2, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + (4)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_APPEND_ONE_FLAT1: do {

 frame_t slot_r, slot_1, slot_2;
 unsigned flags;
 void *ex;

 slot_r = ((uintptr_t)(ip + 1)[0]);
 flags = ((uintptr_t)(ip + 1)[1]);
 slot_1 = ((uintptr_t)(ip + 1)[2]);
 slot_2 = ((uintptr_t)(ip + 1)[3]);

 ex = u_ipret_array_append_one_flat(fp, ip, slot_r, slot_1, slot_2, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + (4)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_APPEND_ONE1: do {

 frame_t slot_r, slot_1, slot_2;
 unsigned flags;
 void *ex;

 slot_r = ((uintptr_t)(ip + 1)[0]);
 flags = ((uintptr_t)(ip + 1)[1]);
 slot_1 = ((uintptr_t)(ip + 1)[2]);
 slot_2 = ((uintptr_t)(ip + 1)[3]);

 ex = u_ipret_array_append_one(fp, ip, slot_r, slot_1, slot_2, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + (4)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_FLATTEN1: do {

 frame_t slot_r, slot_1;
 unsigned flags;
 void *ex;

 slot_r = ((uintptr_t)(ip + 1)[0]);
 flags = ((uintptr_t)(ip + 1)[1]);
 slot_1 = ((uintptr_t)(ip + 1)[2]);

 ex = u_ipret_array_flatten(fp, ip, slot_r, slot_1, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + (3)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 56 "./ipret.inc" 2





# 1 "./ipret-1.inc" 1
# 317 "./ipret-1.inc"
 label_FIXED_binary_add_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_add_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_subtract_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_subtract_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_multiply_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_multiply_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_divide_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_divide_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_udivide_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_udivide_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_modulo_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_modulo_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_umodulo_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_umodulo_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_power_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_power_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_and_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_and_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_or_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_or_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_xor_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_xor_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shl_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shl_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shr_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shr_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ushr_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ushr_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_rol_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_rol_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ror_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ror_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_bts_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bts_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btr_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btr_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btc_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btc_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_equal_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_equal_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_not_equal_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_not_equal_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_less_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_less_equal_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_equal_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_uless_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_uless_equal_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_equal_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_bt_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bt_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_not_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_not_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_neg_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_neg_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_inc_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_inc_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_dec_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_dec_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bswap_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bswap_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_brev_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_brev_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsf_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsf_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsr_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_popcnt_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_to_int_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int8_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_uto_int_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { uint8_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((uint8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)((uint8_t)r != val1), 0)) || (__builtin_expect((int)(r < 0), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 1)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_from_int_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int64_t val1; int8_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int8_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_ufrom_int_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int64_t val1; uint8_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (uint8_t)val1; if ((__builtin_expect((int)((int64_t)r != val1), 0)) || (__builtin_expect((int)(val1 < 0), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_move_int8_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_copy_int8_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_int8_t_2: do { frame_t slot; uint8_t *val; ip_t sz; slot = get_unaligned_32(&(ip + 1)[(0) * 2]); ((void)(zero_())); val = (((uint8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int8_t(val, ip + 1 + ((1) * 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + ((1) * 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_add_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_add_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_subtract_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_subtract_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_multiply_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_multiply_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_divide_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_divide_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_udivide_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_udivide_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_modulo_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_modulo_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_umodulo_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_umodulo_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_power_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_power_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_and_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_and_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_or_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_or_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_xor_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_xor_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shl_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shl_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shr_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shr_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ushr_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ushr_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_rol_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_rol_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ror_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ror_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_bts_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bts_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btr_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btr_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btc_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btc_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_equal_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_equal_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_not_equal_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_not_equal_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_less_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_less_equal_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_equal_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_uless_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_uless_equal_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_equal_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_bt_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bt_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_not_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_not_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_neg_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_neg_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_inc_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_inc_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_dec_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_dec_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bswap_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bswap_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_brev_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_brev_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsf_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsf_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsr_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_popcnt_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_to_int_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int16_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_uto_int_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { uint16_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((uint16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)((uint16_t)r != val1), 0)) || (__builtin_expect((int)(r < 0), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 1)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_from_int_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int64_t val1; int16_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int16_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_ufrom_int_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int64_t val1; uint16_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (uint16_t)val1; if ((__builtin_expect((int)((int64_t)r != val1), 0)) || (__builtin_expect((int)(val1 < 0), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_move_int16_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_copy_int16_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_int16_t_2: do { frame_t slot; uint16_t *val; ip_t sz; slot = get_unaligned_32(&(ip + 1)[(0) * 2]); ((void)(zero_())); val = (((uint16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int16_t(val, ip + 1 + ((1) * 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + ((1) * 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_add_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_add_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_subtract_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_subtract_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_multiply_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_multiply_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_divide_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_divide_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_udivide_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_udivide_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_modulo_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_modulo_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_umodulo_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_umodulo_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_power_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_power_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_and_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_and_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_or_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_or_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_xor_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_xor_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shl_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shl_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shr_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shr_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ushr_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ushr_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_rol_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_rol_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ror_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ror_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_bts_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bts_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btr_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btr_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btc_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btc_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_equal_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_equal_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_not_equal_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_not_equal_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_less_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_less_equal_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_equal_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_uless_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_uless_equal_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_equal_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_bt_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bt_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_not_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_not_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_neg_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_neg_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_inc_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_inc_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_dec_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_dec_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bswap_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bswap_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_brev_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_brev_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsf_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsf_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsr_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_popcnt_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_to_int_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int32_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_uto_int_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { uint32_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((uint32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)((uint32_t)r != val1), 0)) || (__builtin_expect((int)(r < 0), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 1)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_from_int_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int64_t val1; int32_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int32_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_ufrom_int_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int64_t val1; uint32_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (uint32_t)val1; if ((__builtin_expect((int)((int64_t)r != val1), 0)) || (__builtin_expect((int)(val1 < 0), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_move_int32_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_copy_int32_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_int32_t_2: do { frame_t slot; uint32_t *val; ip_t sz; slot = get_unaligned_32(&(ip + 1)[(0) * 2]); ((void)(zero_())); val = (((uint32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int32_t(val, ip + 1 + ((1) * 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + ((1) * 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_add_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_add_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_subtract_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_subtract_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_multiply_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_multiply_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_divide_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_divide_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_udivide_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_udivide_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_modulo_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_modulo_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_umodulo_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_umodulo_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_power_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_power_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_and_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_and_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_or_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_or_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_xor_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_xor_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shl_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shl_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shr_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shr_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ushr_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ushr_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_rol_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_rol_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ror_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ror_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_bts_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bts_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btr_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btr_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btc_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btc_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_equal_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_equal_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_not_equal_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_not_equal_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_less_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_less_equal_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_equal_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_uless_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_uless_equal_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_equal_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_bt_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bt_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_not_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_not_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_neg_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_neg_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_inc_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_inc_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_dec_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_dec_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bswap_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bswap_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_brev_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_brev_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsf_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsf_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsr_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_popcnt_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_to_int_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int64_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_uto_int_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { uint64_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((uint64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)((uint64_t)r != val1), 0)) || (__builtin_expect((int)(r < 0), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 1)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_from_int_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int64_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_ufrom_int_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int64_t val1; uint64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (uint64_t)val1; if ((__builtin_expect((int)((int64_t)r != val1), 0)) || (__builtin_expect((int)(val1 < 0), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_move_int64_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_copy_int64_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_int64_t_2: do { frame_t slot; uint64_t *val; ip_t sz; slot = get_unaligned_32(&(ip + 1)[(0) * 2]); ((void)(zero_())); val = (((uint64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int64_t(val, ip + 1 + ((1) * 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + ((1) * 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_add_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_add_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_subtract_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_subtract_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_multiply_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_multiply_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_divide_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_divide_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_udivide_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_udivide_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_modulo_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_modulo_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_umodulo_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_umodulo_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_power_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_power_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_and_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_and_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_or_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_or_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_xor_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_xor_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shl_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shl_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_shr_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_shr_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ushr_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ushr_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_rol_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_rol_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_ror_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_ror_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_bts_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bts_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btr_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btr_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_btc_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_btc_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_equal_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_equal_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_not_equal_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_not_equal_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_less_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_less_equal_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_less_equal_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_uless_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_binary_uless_equal_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_uless_equal_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_FIXED_binary_bt_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!FIXED_binary_bt_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_not_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_not_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_neg_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_neg_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_inc_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_inc_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_dec_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_dec_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bswap_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bswap_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_brev_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_brev_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsf_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsf_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_bsr_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_popcnt_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_to_int_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int128_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_uto_int_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { uint128_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((uint128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)((uint128_t)r != val1), 0)) || (__builtin_expect((int)(r < 0), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 1)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_from_int_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int64_t val1; int128_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int128_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_unary_ufrom_int_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int64_t val1; uint128_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (uint128_t)val1; if ((__builtin_expect((int)((int64_t)r != val1), 0)) || (__builtin_expect((int)(val1 < 0), 0))) frame_set_pointer(fp, slot_r, u_pointer_error(error_ajla_aux_(1, 5, 0 , "./ipret-1.inc" ":" "317"), fp, ip , "./ipret-1.inc" ":" "317")); else *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_move_int128_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_FIXED_copy_int128_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_int128_t_2: do { frame_t slot; uint128_t *val; ip_t sz; slot = get_unaligned_32(&(ip + 1)[(0) * 2]); ((void)(zero_())); val = (((uint128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int128_t(val, ip + 1 + ((1) * 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + ((1) * 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


label_fixed_ldc16_int32_t_2: do { frame_t slot; uint32_t *val; ip_t sz; slot = get_unaligned_32(&(ip + 1)[(0) * 2]); ((void)(zero_())); val = (((uint32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int32_t(val, ip + 1 + ((1) * 2), 1); __asm__ volatile ("":::"memory"); (ip += (1 + ((1) * 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_fixed_ldc16_int64_t_2: do { frame_t slot; uint64_t *val; ip_t sz; slot = get_unaligned_32(&(ip + 1)[(0) * 2]); ((void)(zero_())); val = (((uint64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int64_t(val, ip + 1 + ((1) * 2), 1); __asm__ volatile ("":::"memory"); (ip += (1 + ((1) * 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_fixed_ldc16_int128_t_2: do { frame_t slot; uint128_t *val; ip_t sz; slot = get_unaligned_32(&(ip + 1)[(0) * 2]); ((void)(zero_())); val = (((uint128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_int128_t(val, ip + 1 + ((1) * 2), 1); __asm__ volatile ("":::"memory"); (ip += (1 + ((1) * 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 420 "./ipret-1.inc"
 label_REAL_binary_add_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_subtract_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_multiply_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_divide_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_modulo_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_modulo_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_power_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_power_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_ldexp_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_ldexp_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_atan2_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_atan2_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_equal_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_not_equal_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_equal_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_neg_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sqrt_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cbrt_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cbrt_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sin_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sin_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cos_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cos_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tan_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tan_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asin_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asin_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acos_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acos_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atan_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atan_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sinh_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sinh_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cosh_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cosh_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tanh_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tanh_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asinh_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asinh_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acosh_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acosh_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atanh_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atanh_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp2_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp2_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp10_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp10_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log2_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log2_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log10_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log10_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_round_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_round_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_ceil_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_ceil_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_floor_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_floor_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_trunc_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_trunc_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_fract_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_fract_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_mantissa_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_mantissa_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exponent_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exponent_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_next_number_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_next_number_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_prev_number_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_prev_number_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_to_int_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_real16_t((((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_from_int_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_real16_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_is_exception_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_real16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_move_real16_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_copy_real16_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_real16_t_2: do { frame_t slot; real16_t *val; ip_t sz; slot = get_unaligned_32(&(ip + 1)[(0) * 2]); ((void)(zero_())); val = (((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_real16_t(val, ip + 1 + ((1) * 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + ((1) * 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_add_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_subtract_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_multiply_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_divide_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_modulo_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_modulo_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_power_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_power_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_ldexp_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_ldexp_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_atan2_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_atan2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_equal_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_not_equal_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_equal_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_neg_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sqrt_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cbrt_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cbrt_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sin_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sin_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cos_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cos_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tan_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tan_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asin_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asin_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acos_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acos_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atan_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atan_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sinh_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sinh_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cosh_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cosh_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tanh_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tanh_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asinh_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asinh_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acosh_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acosh_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atanh_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atanh_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp2_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp2_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp10_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp10_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log2_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log2_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log10_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log10_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_round_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_round_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_ceil_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_ceil_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_floor_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_floor_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_trunc_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_trunc_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_fract_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_fract_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_mantissa_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_mantissa_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exponent_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exponent_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_next_number_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_next_number_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_prev_number_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_prev_number_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_to_int_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_real32_t((((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_from_int_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_real32_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_is_exception_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_move_real32_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_copy_real32_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_real32_t_2: do { frame_t slot; real32_t *val; ip_t sz; slot = get_unaligned_32(&(ip + 1)[(0) * 2]); ((void)(zero_())); val = (((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_real32_t(val, ip + 1 + ((1) * 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + ((1) * 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_add_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_subtract_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_multiply_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_divide_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_modulo_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_modulo_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_power_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_power_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_ldexp_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_ldexp_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_atan2_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_atan2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_equal_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_not_equal_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_equal_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_neg_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sqrt_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cbrt_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cbrt_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sin_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sin_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cos_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cos_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tan_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tan_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asin_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asin_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acos_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acos_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atan_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atan_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sinh_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sinh_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cosh_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cosh_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tanh_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tanh_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asinh_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asinh_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acosh_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acosh_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atanh_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atanh_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp2_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp2_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp10_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp10_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log2_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log2_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log10_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log10_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_round_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_round_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_ceil_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_ceil_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_floor_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_floor_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_trunc_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_trunc_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_fract_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_fract_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_mantissa_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_mantissa_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exponent_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exponent_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_next_number_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_next_number_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_prev_number_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_prev_number_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_to_int_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_real64_t((((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_from_int_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_real64_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_is_exception_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_move_real64_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_copy_real64_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_real64_t_2: do { frame_t slot; real64_t *val; ip_t sz; slot = get_unaligned_32(&(ip + 1)[(0) * 2]); ((void)(zero_())); val = (((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_real64_t(val, ip + 1 + ((1) * 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + ((1) * 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_add_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_subtract_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_multiply_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_divide_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_modulo_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_modulo_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_power_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_power_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_ldexp_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_ldexp_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_atan2_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_atan2_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_equal_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_not_equal_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_binary_less_equal_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_real80_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_neg_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sqrt_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cbrt_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cbrt_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sin_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sin_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cos_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cos_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tan_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tan_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asin_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asin_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acos_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acos_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atan_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atan_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_sinh_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sinh_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_cosh_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_cosh_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_tanh_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_tanh_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_asinh_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_asinh_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_acosh_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_acosh_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_atanh_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_atanh_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp2_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp2_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exp10_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exp10_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log2_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log2_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_log10_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_log10_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_round_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_round_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_ceil_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_ceil_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_floor_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_floor_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_trunc_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_trunc_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_fract_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_fract_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_mantissa_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_mantissa_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_exponent_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_exponent_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_next_number_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_next_number_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_prev_number_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_prev_number_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_unary_to_int_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_real80_t((((real80_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_from_int_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_real80_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real80_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_unary_is_exception_real80_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_real80_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;label_REAL_move_real80_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((real80_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real80_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_REAL_copy_real80_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((real80_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((real80_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_fixed_ldc_real80_t_2: do { frame_t slot; real80_t *val; ip_t sz; slot = get_unaligned_32(&(ip + 1)[(0) * 2]); ((void)(zero_())); val = (((real80_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = fixed_ldc_real80_t(val, ip + 1 + ((1) * 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + ((1) * 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


escape_fixed_binary_thunk_2: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_fixed_operator(fp, ip, get_unaligned_32(&(ip + 1)[(0) * 2]), get_unaligned_32(&(ip + 1)[(1) * 2]), get_unaligned_32(&(ip + 1)[(2) * 2]), get_unaligned_32(&(ip + 1)[(3) * 2])); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + ((4) * 2))); else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 434 "./ipret-1.inc"
escape_fixed_unary_thunk_2: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_fixed_operator(fp, ip, get_unaligned_32(&(ip + 1)[(0) * 2]), ((frame_t)-1), get_unaligned_32(&(ip + 1)[(1) * 2]), get_unaligned_32(&(ip + 1)[(2) * 2])); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + ((3) * 2))); else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 445 "./ipret-1.inc"
escape_convert_thunk_2: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_convert(fp, ip, get_unaligned_32(&(ip + 1)[(0) * 2]), get_unaligned_32(&(ip + 1)[(1) * 2]), get_unaligned_32(&(ip + 1)[(2) * 2])); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + ((3) * 2))); else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 456 "./ipret-1.inc"
{ _Bool ( *function_int_binary)(const mpint_t *s1, const mpint_t *s2, mpint_t *r, ajla_error_t *err); _Bool ( *function_int_binary_logical)(const mpint_t *s1, const mpint_t *s2, ajla_flat_option_t *r, ajla_error_t *err); _Bool ( *function_int_unary)(const mpint_t *s1, mpint_t *r, ajla_error_t *err);
# 655 "./ipret-1.inc"
label_int_binary_add_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_add_int8_t_2: function_int_binary = mpint_add; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_add_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_add_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_subtract_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_subtract_int8_t_2: function_int_binary = mpint_subtract; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_subtract_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_subtract_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_multiply_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_multiply_int8_t_2: function_int_binary = mpint_multiply; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_multiply_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_multiply_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_divide_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_divide_int8_t_2: function_int_binary = mpint_divide; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_divide_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_divide_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_modulo_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_modulo_int8_t_2: function_int_binary = mpint_modulo; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_modulo_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_modulo_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_power_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_power_int8_t_2: function_int_binary = mpint_power; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_power_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_power_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_and_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_and_int8_t_2: function_int_binary = mpint_and; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_and_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_and_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_or_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_or_int8_t_2: function_int_binary = mpint_or; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_or_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_or_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_xor_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_xor_int8_t_2: function_int_binary = mpint_xor; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_xor_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_xor_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shl_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shl_int8_t_2: function_int_binary = mpint_shl; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shl_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shl_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shr_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shr_int8_t_2: function_int_binary = mpint_shr; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shr_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shr_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bts_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_bts_int8_t_2: function_int_binary = mpint_bts; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bts_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_bts_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btr_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btr_int8_t_2: function_int_binary = mpint_btr; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btr_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btr_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btc_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btc_int8_t_2: function_int_binary = mpint_btc; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btc_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btc_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_equal_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_equal_int8_t_2: function_int_binary_logical = mpint_equal; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_equal_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_equal_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_equal_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_not_equal_int8_t_2: function_int_binary_logical = mpint_not_equal; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_not_equal_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_not_equal_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_int8_t_2: function_int_binary_logical = mpint_less; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_equal_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_equal_int8_t_2: function_int_binary_logical = mpint_less_equal; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_equal_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_equal_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bt_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_bt_int8_t_2: function_int_binary_logical = mpint_bt; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bt_int8_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_bt_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_not_int8_t_2: function_int_unary = mpint_not; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_not_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_not_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_neg_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_neg_int8_t_2: function_int_unary = mpint_neg; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_neg_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_neg_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_inc_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_inc_int8_t_2: function_int_unary = mpint_inc; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_inc_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_inc_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_dec_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_dec_int8_t_2: function_int_unary = mpint_dec; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_dec_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_dec_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsf_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsf_int8_t_2: function_int_unary = mpint_bsf; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsf_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsf_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsr_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsr_int8_t_2: function_int_unary = mpint_bsr; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsr_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsr_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_popcnt_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_int8_t_2: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_to_int_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int8_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_from_int_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int64_t val1; int8_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int8_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_move_int8_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_copy_int8_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc_int8_t_2: do { frame_t slot; int8_t *val; ip_t sz; slot = get_unaligned_32(&(ip + 1)[(0) * 2]); ((void)(zero_())); val = (((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int8_t(val, ip + 1 + ((1) * 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + ((1) * 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc16_int8_t_2: do { frame_t slot; int8_t *val; ip_t sz; slot = get_unaligned_32(&(ip + 1)[(0) * 2]); ((void)(zero_())); val = (((int8_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int8_t(val, ip + 1 + ((1) * 2), 1); __asm__ volatile ("":::"memory"); (ip += (1 + ((1) * 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_add_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_add_int16_t_2: function_int_binary = mpint_add; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_add_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_add_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_subtract_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_subtract_int16_t_2: function_int_binary = mpint_subtract; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_subtract_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_subtract_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_multiply_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_multiply_int16_t_2: function_int_binary = mpint_multiply; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_multiply_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_multiply_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_divide_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_divide_int16_t_2: function_int_binary = mpint_divide; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_divide_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_divide_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_modulo_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_modulo_int16_t_2: function_int_binary = mpint_modulo; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_modulo_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_modulo_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_power_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_power_int16_t_2: function_int_binary = mpint_power; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_power_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_power_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_and_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_and_int16_t_2: function_int_binary = mpint_and; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_and_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_and_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_or_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_or_int16_t_2: function_int_binary = mpint_or; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_or_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_or_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_xor_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_xor_int16_t_2: function_int_binary = mpint_xor; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_xor_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_xor_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shl_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shl_int16_t_2: function_int_binary = mpint_shl; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shl_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shl_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shr_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shr_int16_t_2: function_int_binary = mpint_shr; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shr_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shr_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bts_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_bts_int16_t_2: function_int_binary = mpint_bts; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bts_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_bts_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btr_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btr_int16_t_2: function_int_binary = mpint_btr; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btr_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btr_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btc_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btc_int16_t_2: function_int_binary = mpint_btc; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btc_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btc_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_equal_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_equal_int16_t_2: function_int_binary_logical = mpint_equal; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_equal_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_equal_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_equal_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_not_equal_int16_t_2: function_int_binary_logical = mpint_not_equal; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_not_equal_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_not_equal_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_int16_t_2: function_int_binary_logical = mpint_less; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_equal_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_equal_int16_t_2: function_int_binary_logical = mpint_less_equal; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_equal_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_equal_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bt_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_bt_int16_t_2: function_int_binary_logical = mpint_bt; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bt_int16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_bt_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_not_int16_t_2: function_int_unary = mpint_not; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_not_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_not_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_neg_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_neg_int16_t_2: function_int_unary = mpint_neg; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_neg_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_neg_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_inc_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_inc_int16_t_2: function_int_unary = mpint_inc; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_inc_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_inc_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_dec_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_dec_int16_t_2: function_int_unary = mpint_dec; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_dec_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_dec_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsf_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsf_int16_t_2: function_int_unary = mpint_bsf; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsf_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsf_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsr_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsr_int16_t_2: function_int_unary = mpint_bsr; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsr_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsr_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_popcnt_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_int16_t_2: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_to_int_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int16_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_from_int_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int64_t val1; int16_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int16_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_move_int16_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_copy_int16_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc_int16_t_2: do { frame_t slot; int16_t *val; ip_t sz; slot = get_unaligned_32(&(ip + 1)[(0) * 2]); ((void)(zero_())); val = (((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int16_t(val, ip + 1 + ((1) * 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + ((1) * 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc16_int16_t_2: do { frame_t slot; int16_t *val; ip_t sz; slot = get_unaligned_32(&(ip + 1)[(0) * 2]); ((void)(zero_())); val = (((int16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int16_t(val, ip + 1 + ((1) * 2), 1); __asm__ volatile ("":::"memory"); (ip += (1 + ((1) * 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_add_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_add_int32_t_2: function_int_binary = mpint_add; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_add_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_add_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_subtract_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_subtract_int32_t_2: function_int_binary = mpint_subtract; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_subtract_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_subtract_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_multiply_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_multiply_int32_t_2: function_int_binary = mpint_multiply; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_multiply_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_multiply_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_divide_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_divide_int32_t_2: function_int_binary = mpint_divide; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_divide_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_divide_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_modulo_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_modulo_int32_t_2: function_int_binary = mpint_modulo; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_modulo_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_modulo_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_power_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_power_int32_t_2: function_int_binary = mpint_power; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_power_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_power_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_and_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_and_int32_t_2: function_int_binary = mpint_and; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_and_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_and_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_or_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_or_int32_t_2: function_int_binary = mpint_or; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_or_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_or_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_xor_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_xor_int32_t_2: function_int_binary = mpint_xor; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_xor_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_xor_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shl_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shl_int32_t_2: function_int_binary = mpint_shl; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shl_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shl_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shr_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shr_int32_t_2: function_int_binary = mpint_shr; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shr_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shr_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bts_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_bts_int32_t_2: function_int_binary = mpint_bts; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bts_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_bts_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btr_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btr_int32_t_2: function_int_binary = mpint_btr; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btr_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btr_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btc_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btc_int32_t_2: function_int_binary = mpint_btc; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btc_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btc_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_equal_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_equal_int32_t_2: function_int_binary_logical = mpint_equal; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_equal_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_equal_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_equal_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_not_equal_int32_t_2: function_int_binary_logical = mpint_not_equal; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_not_equal_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_not_equal_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_int32_t_2: function_int_binary_logical = mpint_less; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_equal_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_equal_int32_t_2: function_int_binary_logical = mpint_less_equal; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_equal_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_equal_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bt_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_bt_int32_t_2: function_int_binary_logical = mpint_bt; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bt_int32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_bt_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_not_int32_t_2: function_int_unary = mpint_not; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_not_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_not_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_neg_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_neg_int32_t_2: function_int_unary = mpint_neg; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_neg_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_neg_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_inc_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_inc_int32_t_2: function_int_unary = mpint_inc; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_inc_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_inc_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_dec_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_dec_int32_t_2: function_int_unary = mpint_dec; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_dec_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_dec_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsf_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsf_int32_t_2: function_int_unary = mpint_bsf; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsf_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsf_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsr_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsr_int32_t_2: function_int_unary = mpint_bsr; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsr_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsr_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_popcnt_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_int32_t_2: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_to_int_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int32_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_from_int_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int64_t val1; int32_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int32_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_move_int32_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_copy_int32_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc_int32_t_2: do { frame_t slot; int32_t *val; ip_t sz; slot = get_unaligned_32(&(ip + 1)[(0) * 2]); ((void)(zero_())); val = (((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int32_t(val, ip + 1 + ((1) * 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + ((1) * 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc16_int32_t_2: do { frame_t slot; int32_t *val; ip_t sz; slot = get_unaligned_32(&(ip + 1)[(0) * 2]); ((void)(zero_())); val = (((int32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int32_t(val, ip + 1 + ((1) * 2), 1); __asm__ volatile ("":::"memory"); (ip += (1 + ((1) * 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_add_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_add_int64_t_2: function_int_binary = mpint_add; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_add_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_add_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_subtract_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_subtract_int64_t_2: function_int_binary = mpint_subtract; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_subtract_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_subtract_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_multiply_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_multiply_int64_t_2: function_int_binary = mpint_multiply; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_multiply_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_multiply_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_divide_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_divide_int64_t_2: function_int_binary = mpint_divide; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_divide_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_divide_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_modulo_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_modulo_int64_t_2: function_int_binary = mpint_modulo; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_modulo_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_modulo_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_power_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_power_int64_t_2: function_int_binary = mpint_power; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_power_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_power_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_and_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_and_int64_t_2: function_int_binary = mpint_and; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_and_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_and_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_or_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_or_int64_t_2: function_int_binary = mpint_or; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_or_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_or_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_xor_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_xor_int64_t_2: function_int_binary = mpint_xor; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_xor_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_xor_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shl_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shl_int64_t_2: function_int_binary = mpint_shl; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shl_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shl_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shr_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shr_int64_t_2: function_int_binary = mpint_shr; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shr_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shr_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bts_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_bts_int64_t_2: function_int_binary = mpint_bts; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bts_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_bts_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btr_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btr_int64_t_2: function_int_binary = mpint_btr; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btr_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btr_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btc_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btc_int64_t_2: function_int_binary = mpint_btc; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btc_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btc_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_equal_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_equal_int64_t_2: function_int_binary_logical = mpint_equal; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_equal_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_equal_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_equal_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_not_equal_int64_t_2: function_int_binary_logical = mpint_not_equal; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_not_equal_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_not_equal_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_int64_t_2: function_int_binary_logical = mpint_less; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_equal_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_equal_int64_t_2: function_int_binary_logical = mpint_less_equal; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_equal_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_equal_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bt_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_bt_int64_t_2: function_int_binary_logical = mpint_bt; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bt_int64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_bt_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_not_int64_t_2: function_int_unary = mpint_not; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_not_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_not_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_neg_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_neg_int64_t_2: function_int_unary = mpint_neg; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_neg_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_neg_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_inc_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_inc_int64_t_2: function_int_unary = mpint_inc; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_inc_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_inc_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_dec_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_dec_int64_t_2: function_int_unary = mpint_dec; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_dec_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_dec_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsf_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsf_int64_t_2: function_int_unary = mpint_bsf; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsf_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsf_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsr_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsr_int64_t_2: function_int_unary = mpint_bsr; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsr_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsr_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_popcnt_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_int64_t_2: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_to_int_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int64_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_from_int_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int64_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_move_int64_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_copy_int64_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc_int64_t_2: do { frame_t slot; int64_t *val; ip_t sz; slot = get_unaligned_32(&(ip + 1)[(0) * 2]); ((void)(zero_())); val = (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int64_t(val, ip + 1 + ((1) * 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + ((1) * 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc16_int64_t_2: do { frame_t slot; int64_t *val; ip_t sz; slot = get_unaligned_32(&(ip + 1)[(0) * 2]); ((void)(zero_())); val = (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int64_t(val, ip + 1 + ((1) * 2), 1); __asm__ volatile ("":::"memory"); (ip += (1 + ((1) * 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_add_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_add_int128_t_2: function_int_binary = mpint_add; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_add_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_add_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_subtract_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_subtract_int128_t_2: function_int_binary = mpint_subtract; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_subtract_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_subtract_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_multiply_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_multiply_int128_t_2: function_int_binary = mpint_multiply; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_multiply_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_multiply_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_divide_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_divide_int128_t_2: function_int_binary = mpint_divide; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_divide_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_divide_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_modulo_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_modulo_int128_t_2: function_int_binary = mpint_modulo; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_modulo_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_modulo_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_power_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_power_int128_t_2: function_int_binary = mpint_power; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_power_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_power_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_and_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_and_int128_t_2: function_int_binary = mpint_and; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_and_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_and_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_or_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_or_int128_t_2: function_int_binary = mpint_or; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_or_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_or_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_xor_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_xor_int128_t_2: function_int_binary = mpint_xor; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_xor_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_xor_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shl_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shl_int128_t_2: function_int_binary = mpint_shl; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shl_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shl_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_shr_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_shr_int128_t_2: function_int_binary = mpint_shr; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_shr_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_shr_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bts_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_bts_int128_t_2: function_int_binary = mpint_bts; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bts_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_bts_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btr_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btr_int128_t_2: function_int_binary = mpint_btr; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btr_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btr_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_btc_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_btc_int128_t_2: function_int_binary = mpint_btc; goto escape_int_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_btc_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_btc_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_equal_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_equal_int128_t_2: function_int_binary_logical = mpint_equal; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_equal_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_equal_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_equal_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_not_equal_int128_t_2: function_int_binary_logical = mpint_not_equal; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_not_equal_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_not_equal_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_int128_t_2: function_int_binary_logical = mpint_less; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_less_equal_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_less_equal_int128_t_2: function_int_binary_logical = mpint_less_equal; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_less_equal_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_less_equal_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bt_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { escape_int_binary_logical_bt_int128_t_2: function_int_binary_logical = mpint_bt; goto escape_int_binary_logical_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_binary_bt_int128_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_binary_logical_bt_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_not_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_not_int128_t_2: function_int_unary = mpint_not; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_not_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_not_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_neg_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_neg_int128_t_2: function_int_unary = mpint_neg; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_neg_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_neg_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_inc_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_inc_int128_t_2: function_int_unary = mpint_inc; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_inc_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_inc_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_dec_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_dec_int128_t_2: function_int_unary = mpint_dec; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_dec_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_dec_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsf_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsf_int128_t_2: function_int_unary = mpint_bsf; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsf_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsf_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_bsr_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_bsr_int128_t_2: function_int_unary = mpint_bsr; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_bsr_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_bsr_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_binary_popcnt_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_int128_t_2: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_to_int_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int128_t val1; int64_t r; __asm__ volatile ("":::"memory"); val1 = *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int64_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_unary_from_int_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { int64_t val1; int128_t r; __asm__ volatile ("":::"memory"); val1 = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); r = (int128_t)val1; if ((__builtin_expect((int)(r != val1), 0))) frame_set_pointer(fp, slot_r, u_convert_fixed_to_mpint(val1, 0)); else *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = r; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_move_int128_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_INT_copy_int128_t_2: do { do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc_int128_t_2: do { frame_t slot; int128_t *val; ip_t sz; slot = get_unaligned_32(&(ip + 1)[(0) * 2]); ((void)(zero_())); val = (((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int128_t(val, ip + 1 + ((1) * 2), 0); __asm__ volatile ("":::"memory"); (ip += (1 + ((1) * 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;; label_int_ldc16_int128_t_2: do { frame_t slot; int128_t *val; ip_t sz; slot = get_unaligned_32(&(ip + 1)[(0) * 2]); ((void)(zero_())); val = (((int128_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); __asm__ volatile ("":::"memory"); sz = int_ldc_int128_t(val, ip + 1 + ((1) * 2), 1); __asm__ volatile ("":::"memory"); (ip += (1 + ((1) * 2))); (ip += (sz)); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

escape_int_binary_thunk_2: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_int_binary_operator(fp, ip, get_unaligned_32(&(ip + 1)[(0) * 2]), get_unaligned_32(&(ip + 1)[(1) * 2]), get_unaligned_32(&(ip + 1)[(2) * 2]), get_unaligned_32(&(ip + 1)[(3) * 2]), function_int_binary); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + ((4) * 2))); else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 667 "./ipret-1.inc"
escape_int_binary_logical_thunk_2: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_int_binary_logical_operator(fp, ip, get_unaligned_32(&(ip + 1)[(0) * 2]), get_unaligned_32(&(ip + 1)[(1) * 2]), get_unaligned_32(&(ip + 1)[(2) * 2]), get_unaligned_32(&(ip + 1)[(3) * 2]), function_int_binary_logical); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + ((4) * 2))); else if (ex != ((void *)(uintptr_t)1)) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 677 "./ipret-1.inc"
escape_int_unary_thunk_2: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_int_unary_operator(fp, ip, get_unaligned_32(&(ip + 1)[(0) * 2]), get_unaligned_32(&(ip + 1)[(1) * 2]), get_unaligned_32(&(ip + 1)[(2) * 2]), function_int_unary); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + ((3) * 2))); else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 688 "./ipret-1.inc"
# 1 "./for-fix.inc" 1
# 24 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_bsr_alt1_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_alt1_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_popcnt_alt1_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_alt1_int8_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 74 "./ipret-a1.inc" 2
# 25 "./for-fix.inc" 2
# 36 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_bsr_alt1_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_alt1_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_popcnt_alt1_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_alt1_int16_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 74 "./ipret-a1.inc" 2
# 37 "./for-fix.inc" 2
# 48 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_bsr_alt1_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_alt1_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_popcnt_alt1_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_alt1_int32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 74 "./ipret-a1.inc" 2
# 49 "./for-fix.inc" 2
# 60 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_bsr_alt1_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_alt1_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_popcnt_alt1_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_alt1_int64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 74 "./ipret-a1.inc" 2
# 61 "./for-fix.inc" 2
# 72 "./for-fix.inc"
# 1 "./ipret-a1.inc" 1
# 25 "./ipret-a1.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 38 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 44 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 50 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 56 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 62 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_bsr_alt1_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_bsr_alt1_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 68 "./ipret-a1.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_FIXED_unary_popcnt_alt1_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); FIXED_unary_popcnt_alt1_int128_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 74 "./ipret-a1.inc" 2
# 73 "./for-fix.inc" 2
# 689 "./ipret-1.inc" 2


# 1 "./for-int.inc" 1
# 24 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_int_binary_popcnt_alt1_int8_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_alt1_int8_t_2: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_alt1_int8_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_alt1_int8_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 38 "./ipret-a2.inc" 2
# 25 "./for-int.inc" 2
# 36 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_int_binary_popcnt_alt1_int16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_alt1_int16_t_2: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_alt1_int16_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_alt1_int16_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 38 "./ipret-a2.inc" 2
# 37 "./for-int.inc" 2
# 48 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_int_binary_popcnt_alt1_int32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_alt1_int32_t_2: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_alt1_int32_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_alt1_int32_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 38 "./ipret-a2.inc" 2
# 49 "./for-int.inc" 2
# 60 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_int_binary_popcnt_alt1_int64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_alt1_int64_t_2: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_alt1_int64_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_alt1_int64_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 38 "./ipret-a2.inc" 2
# 61 "./for-int.inc" 2
# 72 "./for-int.inc"
# 1 "./ipret-a2.inc" 1
# 25 "./ipret-a2.inc"
# 1 "./ipret-b1.inc" 1
# 26 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 32 "./ipret-a2.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_int_binary_popcnt_alt1_int128_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { escape_int_unary_popcnt_alt1_int128_t_2: function_int_unary = mpint_popcnt; goto escape_int_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!INT_unary_popcnt_alt1_int128_t(val1, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_int_unary_popcnt_alt1_int128_t_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 38 "./ipret-a2.inc" 2
# 73 "./for-int.inc" 2
# 692 "./ipret-1.inc" 2


# 1 "./for-real.inc" 1
# 23 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_add_alt1_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_subtract_alt1_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_multiply_alt1_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_divide_alt1_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_equal_alt1_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_not_equal_alt1_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_alt1_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_equal_alt1_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_alt1_real16_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 118 "./ipret-a3.inc" 2
# 149 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_to_int_alt1_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_alt1_real16_t((((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 150 "./ipret-a3.inc" 2
# 163 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_from_int_alt1_real16_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_alt1_real16_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real16_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 164 "./ipret-a3.inc" 2
# 24 "./for-real.inc" 2
# 33 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_add_alt1_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_add_alt2_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_subtract_alt1_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_subtract_alt2_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_multiply_alt1_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_multiply_alt2_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_divide_alt1_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_divide_alt2_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_equal_alt1_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_equal_alt2_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_not_equal_alt1_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_not_equal_alt2_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_alt1_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_alt2_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_equal_alt1_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_alt1_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_equal_alt2_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_alt2_real32_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 118 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_neg_alt1_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_alt1_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 125 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_neg_alt2_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_alt2_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 131 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_sqrt_alt1_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_alt1_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 137 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_sqrt_alt2_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_alt2_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 143 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_to_int_alt1_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_alt1_real32_t((((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 150 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_to_int_alt2_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_alt2_real32_t((((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 157 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_from_int_alt1_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_alt1_real32_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 164 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_from_int_alt2_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_alt2_real32_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real32_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 171 "./ipret-a3.inc" 2







# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_is_exception_alt1_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_alt1_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 179 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_is_exception_alt2_real32_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_alt2_real32_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 185 "./ipret-a3.inc" 2
# 34 "./for-real.inc" 2
# 43 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 27 "./ipret-a3.inc"
# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_add_alt1_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 28 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_add_alt2_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_add_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 34 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_subtract_alt1_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 40 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_subtract_alt2_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_subtract_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 46 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_multiply_alt1_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 52 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_multiply_alt2_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_multiply_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 58 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_divide_alt1_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 64 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_divide_alt2_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_divide_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 70 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_equal_alt1_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 76 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_equal_alt2_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_equal_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 82 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_not_equal_alt1_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 88 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_not_equal_alt2_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_not_equal_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 94 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_alt1_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 100 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_alt2_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 106 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_equal_alt1_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_alt1_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 112 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_binary_less_equal_alt2_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { goto escape_fixed_binary_thunk_2; } else { const void *val1; const void *val2; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); val2 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!REAL_binary_less_equal_alt2_real64_t(val1, val2, result)), 0))) { __asm__ volatile ("":::"memory"); goto escape_fixed_binary_thunk_2; } __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 118 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_neg_alt1_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_alt1_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 125 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_neg_alt2_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_neg_alt2_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 131 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_sqrt_alt1_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_alt1_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 137 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_sqrt_alt2_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_sqrt_alt2_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 143 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_to_int_alt1_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_alt1_real64_t((((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 150 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_to_int_alt2_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { _Bool ret; __asm__ volatile ("":::"memory"); ret = REAL_unary_to_int_alt2_real64_t((((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(!ret), 0))) frame_set_pointer(fp, slot_r, u_convert_real_to_mpint(fp, slot_1, frame_get_type_of_local(fp, slot_1))); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 157 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_from_int_alt1_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_alt1_real64_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 164 "./ipret-a3.inc" 2






# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_from_int_alt2_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_convert_thunk_2; } else { __asm__ volatile ("":::"memory"); REAL_unary_from_int_alt2_real64_t((((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), (((real64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 171 "./ipret-a3.inc" 2







# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_is_exception_alt1_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_alt1_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 179 "./ipret-a3.inc" 2





# 1 "./ipret-b1.inc" 1
# 23 "./ipret-b1.inc"
label_REAL_unary_is_exception_alt2_real64_t_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_fixed_unary_thunk_2; } else { const void *val1; void *result; val1 = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))); __asm__ volatile ("":::"memory"); REAL_unary_is_exception_alt2_real64_t(val1, result); __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 185 "./ipret-a3.inc" 2
# 44 "./for-real.inc" 2
# 53 "./for-real.inc"
# 1 "./ipret-a3.inc" 1
# 54 "./for-real.inc" 2
# 695 "./ipret-1.inc" 2

}
# 748 "./ipret-1.inc"
label_bool_binary_and_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { ((void)(zero_())); goto escape_bool_binary_thunk_2; } else { ajla_flat_option_t val1; ajla_flat_option_t val2; ajla_flat_option_t result; __asm__ volatile ("":::"memory"); val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); val2 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); result = val1 & val2; *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = result; __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
label_bool_binary_or_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { ((void)(zero_())); goto escape_bool_binary_thunk_2; } else { ajla_flat_option_t val1; ajla_flat_option_t val2; ajla_flat_option_t result; __asm__ volatile ("":::"memory"); val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); val2 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); result = val1 | val2; *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = result; __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
label_bool_binary_equal_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { ((void)(zero_())); goto escape_bool_binary_thunk_2; } else { ajla_flat_option_t val1; ajla_flat_option_t val2; ajla_flat_option_t result; __asm__ volatile ("":::"memory"); val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); val2 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); result = val1 == val2; *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = result; __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
label_bool_binary_not_equal_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { ((void)(zero_())); goto escape_bool_binary_thunk_2; } else { ajla_flat_option_t val1; ajla_flat_option_t val2; ajla_flat_option_t result; __asm__ volatile ("":::"memory"); val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); val2 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); result = val1 ^ val2; *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = result; __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
label_bool_binary_less_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { ((void)(zero_())); goto escape_bool_binary_thunk_2; } else { ajla_flat_option_t val1; ajla_flat_option_t val2; ajla_flat_option_t result; __asm__ volatile ("":::"memory"); val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); val2 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); result = val1 < val2; *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = result; __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
label_bool_binary_less_equal_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_2 = get_unaligned_32(&(ip + 1)[(1) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]); if ((__builtin_expect((int)(((((unsigned char *)(void *)(fp)))[slot_1] | (((unsigned char *)(void *)(fp)))[slot_2])), 0))) { ((void)(zero_())); goto escape_bool_binary_thunk_2; } else { ajla_flat_option_t val1; ajla_flat_option_t val2; ajla_flat_option_t result; __asm__ volatile ("":::"memory"); val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); val2 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_2) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); result = val1 <= val2; *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = result; __asm__ volatile ("":::"memory"); (ip += (1 + ((4) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
label_bool_unary_not_2: do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { goto escape_bool_unary_thunk_2; } else { ajla_flat_option_t val1; ajla_flat_option_t result; __asm__ volatile ("":::"memory"); val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); result = val1 ^ 1; *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = result; __asm__ volatile ("":::"memory"); (ip += (1 + ((3) * 2))); } } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

escape_bool_binary_thunk_2: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_bool_operator(fp, ip, get_unaligned_32(&(ip + 1)[(0) * 2]), get_unaligned_32(&(ip + 1)[(1) * 2]), get_unaligned_32(&(ip + 1)[(2) * 2]), get_unaligned_32(&(ip + 1)[(3) * 2])); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + ((4) * 2))); else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 766 "./ipret-1.inc"
escape_bool_unary_thunk_2: do { void *ex; __asm__ volatile ("":::"memory"); ex = u_thunk_bool_operator(fp, ip, get_unaligned_32(&(ip + 1)[(0) * 2]), ((frame_t)-1), get_unaligned_32(&(ip + 1)[(1) * 2]), get_unaligned_32(&(ip + 1)[(2) * 2])); if (ex == ((void *)(uintptr_t)3)) (ip += (1 + ((3) * 2))); else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 777 "./ipret-1.inc"
label_bool_move_2: do {

 do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_and_clear_flag(fp, slot_1)), 0))) { frame_set_pointer(fp, slot_r, *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); } else { *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0);

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_bool_copy_2: do {

 do { frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]); frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]); ((void)(zero_())); __asm__ volatile ("":::"memory"); if ((__builtin_expect((int)(frame_test_flag(fp, slot_1)), 0))) { pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); frame_set_pointer(fp, slot_r, ptr); pointer_reference_owned(ptr); } else { *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))); } __asm__ volatile ("":::"memory"); (ip += (1 + ((2) * 2))); } while (0);

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


label_OPCODE_INT_LDC_LONG2: do {

 frame_t slot;
 ip_t sz;
 slot = get_unaligned_32(&(ip + 1)[(0) * 2]);
 sz = u_ipret_int_ldc_long(fp, slot, ip + 1 + ((1) * 2));
 (ip += (1 + ((1) * 2)));
 (ip += (sz));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


label_OPCODE_IS_EXCEPTION2: do {

 frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]);
 frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]);
 ((void)(zero_()));
 if (!frame_variable_is_flat(fp, slot_1)) {
  void *ex = u_is_thunk_operator(fp, ip, slot_1, slot_r, get_unaligned_32(&(ip + 1)[(2) * 2]));
  if (ex == ((void *)(uintptr_t)3))
   (ip += (1 + ((3) * 2)));
  else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0)))
   do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
 } else {
  __asm__ volatile ("":::"memory");
  *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = 0;
  __asm__ volatile ("":::"memory");
  (ip += (1 + ((3) * 2)));
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_EXCEPTION_CLASS2: do {

 void *ex;
 ex = u_thunk_get_param(fp, ip, get_unaligned_32(&(ip + 1)[(0) * 2]), get_unaligned_32(&(ip + 1)[(1) * 2]), get_unaligned_32(&(ip + 1)[(2) * 2]), 0);
 if ((__builtin_expect((int)(ex == ((void *)(uintptr_t)3)), 1)))
  (ip += (1 + ((3) * 2)));
 else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_EXCEPTION_TYPE2: do {

 void *ex;
 ex = u_thunk_get_param(fp, ip, get_unaligned_32(&(ip + 1)[(0) * 2]), get_unaligned_32(&(ip + 1)[(1) * 2]), get_unaligned_32(&(ip + 1)[(2) * 2]), 1);
 if ((__builtin_expect((int)(ex == ((void *)(uintptr_t)3)), 1)))
  (ip += (1 + ((3) * 2)));
 else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_EXCEPTION_AUX2: do {

 void *ex;
 ex = u_thunk_get_param(fp, ip, get_unaligned_32(&(ip + 1)[(0) * 2]), get_unaligned_32(&(ip + 1)[(1) * 2]), get_unaligned_32(&(ip + 1)[(2) * 2]), 2);
 if ((__builtin_expect((int)(ex == ((void *)(uintptr_t)3)), 1)))
  (ip += (1 + ((3) * 2)));
 else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_SYSTEM_PROPERTY2: do {

 void *ex;
 ex = u_ipret_get_system_property(fp, ip, get_unaligned_32(&(ip + 1)[(0) * 2]), get_unaligned_32(&(ip + 1)[(1) * 2]));
 if ((__builtin_expect((int)(ex == ((void *)(uintptr_t)3)), 1)))
  (ip += (1 + ((3) * 2)));
 else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


label_OPCODE_FLAT_MOVE2: do {

 frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]);
 frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]);
 if ((__builtin_expect((int)(frame_variable_is_flat(fp, slot_1)), 1))) {
  memcpy((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), frame_get_type_of_local(fp, slot_1)->size);
 } else {
  pointer_t ptr = frame_get_pointer_reference(fp, slot_1, 1);
  frame_set_pointer(fp, slot_r, ptr);
 }
 (ip += (1 + ((2) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_FLAT_COPY2: do {

 frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]);
 frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]);
 if ((__builtin_expect((int)(frame_variable_is_flat(fp, slot_1)), 1))) {
  memcpy((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), frame_get_type_of_local(fp, slot_1)->size);
 } else {
  pointer_t ptr = frame_get_pointer_reference(fp, slot_1, 0);
  frame_set_pointer(fp, slot_r, ptr);
 }
 (ip += (1 + ((2) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_REF_MOVE2: do {

 frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]);
 frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]);
 pointer_t ptr = frame_get_pointer_reference(fp, slot_1, 1);
 pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))));
 frame_set_pointer(fp, slot_r, ptr);
 (ip += (1 + ((2) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_REF_MOVE_CLEAR2: do {

 frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]);
 frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]);
 pointer_t ptr = frame_get_pointer_reference(fp, slot_1, 1);
 frame_set_pointer(fp, slot_r, ptr);
 (ip += (1 + ((2) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_REF_COPY2: do {

 frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]);
 frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]);
 pointer_t ptr = frame_get_pointer_reference(fp, slot_1, 0);
 frame_set_pointer(fp, slot_r, ptr);
 (ip += (1 + ((2) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_BOX_MOVE_CLEAR2: do {

 frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]);
 frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]);
 pointer_t ptr = u_ipret_copy_variable_to_pointer(fp, slot_1, 1);
 *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = pointer_empty();
 frame_set_pointer(fp, slot_r, ptr);
 (ip += (1 + ((2) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_BOX_COPY2: do {

 frame_t slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]);
 frame_t slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]);
 pointer_t ptr = u_ipret_copy_variable_to_pointer(fp, slot_1, 0);
 frame_set_pointer(fp, slot_r, ptr);
 (ip += (1 + ((2) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_TAKE_BORROWED2: do {

 frame_t slot = get_unaligned_32(&(ip + 1)[(0) * 2]);
 if (!frame_test_and_set_flag(fp, slot)) {
  pointer_t ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
  pointer_reference_owned(ptr);
 }
 (ip += (1 + ((1) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


label_OPCODE_DEREFERENCE2: do {

 frame_t slot = get_unaligned_32(&(ip + 1)[(0) * 2]);
# 971 "./ipret-1.inc"
 frame_free(fp, slot);
 pointer_poison((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))));
 (ip += (1 + ((1) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_DEREFERENCE_CLEAR2: do {

 frame_t slot = get_unaligned_32(&(ip + 1)[(0) * 2]);
# 989 "./ipret-1.inc"
 frame_free_and_clear(fp, slot);
 (ip += (1 + ((1) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_EVAL2: do {

 frame_t slot = get_unaligned_32(&(ip + 1)[(0) * 2]);
 if (frame_test_flag(fp, slot)) {
  pointer_t *ptr = (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
  struct data __attribute__((__unused__)) *result;

  do { pointer_t p_; if (!(1)) p_ = pointer_locked_read(ptr); else p_ = *(ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (result) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1003"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(ptr, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(ptr) , "./ipret-1.inc" ":" "1003"); { goto eval_skip_2; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);
# 1010 "./ipret-1.inc"
eval_skip_2:;
 }
 (ip += (1 + ((1) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


label_OPCODE_CHECKPOINT2: do {


 frame_t id = get_unaligned_32(&(ip + 1)[(0) * 2]);
 const code_t __attribute__((__unused__)) *orig_ip = ip;

 (ip += (1 + ((1) * 2)));

 if ((__builtin_expect((int)(((__builtin_expect((int)(*(&ts) != __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)), 0)))), 0)) && (__builtin_expect((int)(frame_execution_control(fp) != ((void*)0)), 1))) {
  do { void *ex_ = u_ipret_tick(fp, ip); do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0);
 } else {

  struct data *fn = (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function;
  code_return_t r;
  void *new_fp;
  ip_t new_ip;
  struct data *codegen;
  if ((__builtin_expect((int)(__c11_atomic_load(&((((void)(zero_()))), &(fn)->u_.function)->codegen_failed, 0)), 0)))
   goto checkpoint_exit_2;

  do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(&((((void)(zero_()))), &(fn)->u_.function)->codegen); else p_ = *(&((((void)(zero_()))), &(fn)->u_.function)->codegen); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (codegen) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1041"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(&((((void)(zero_()))), &(fn)->u_.function)->codegen, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(&((((void)(zero_()))), &(fn)->u_.function)->codegen) , "./ipret-1.inc" ":" "1041"); { __c11_atomic_store(&((((void)(zero_()))), &(fn)->u_.function)->codegen_failed, 1, 0); goto checkpoint_exit_2;; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, orig_ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);
# 1068 "./ipret-1.inc"
  r = u_codegen_entry(fp, &u_cg_upcall_vector, ts, ((((void)(zero_()))), &(codegen)->u_.codegen)->unoptimized_code[id]);
# 1078 "./ipret-1.inc"
  new_fp = r.fp;
  new_ip = r.ip;


  if ((__builtin_expect((int)(new_ip == (ip_t)-1), 0))) {

   do { if ((new_fp) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((new_fp)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((new_fp)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
  } else {

   fp = new_fp;
   ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + new_ip;
   if ((__builtin_expect((int)(profiling_escapes), 0))) {
    profile_counter_t profiling_counter;
    fn = (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function;
    profiling_counter = __c11_atomic_load(&((((void)(zero_()))), &(fn)->u_.function)->escape_data[new_ip].counter, 0);
    profiling_counter++;
    __c11_atomic_store(&((((void)(zero_()))), &(fn)->u_.function)->escape_data[new_ip].counter, profiling_counter, 0);
   }
  }

  goto checkpoint_exit_2;
checkpoint_exit_2:;
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 1134 "./ipret-1.inc"
label_OPCODE_JMP_FALSE2: do {

 int32_t offset;
 frame_t slot;
 ajla_flat_option_t val1;

 slot = get_unaligned_32(&(ip + 1)[(0) * 2]);
 if ((__builtin_expect((int)(frame_test_flag(fp, slot)), 0))) {
  void *ex = u_thunk_bool_jump(fp, ip, slot);
  if (ex != ((void *)(uintptr_t)1)) {
   if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)2)), 1))) {
    do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
   } else {
    if (4 == 2) {
     offset = ip[1 + ((1) * 2) + 1];
     (ip += (1 + ((1) * 2)));
     (ip += (2));
    } else if (4 == 4) {
     offset = get_unaligned_32(&ip[1 + ((1) * 2) + 2]);
     (ip += (1 + ((1) * 2)));
     (ip += (4));
    } else {
     not_reached();
    }
    ip = ((const code_t *)(void *)(((const char *)(void *)(ip)) + offset));
    goto jmp_false_exception_2;
   }
  }
 }
 __asm__ volatile ("":::"memory");
 val1 = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
 __asm__ volatile ("":::"memory");
 if (4 == 2) {
  offset = ip[1 + ((1) * 2)];
  (ip += (1 + ((1) * 2)));
  (ip += (2));
 } else if (4 == 4) {
  offset = get_unaligned_32(&ip[1 + ((1) * 2)]);
  (ip += (1 + ((1) * 2)));
  (ip += (4));
 } else {
  not_reached();
 }
 if (!val1)
  ip = ((const code_t *)(void *)(((const char *)(void *)(ip)) + offset));

jmp_false_exception_2:;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 1193 "./ipret-1.inc"
{ pointer_t *direct_data; pointer_t indirect_data; arg_t n_arguments; frame_t result_slot; struct thunk *function_error;







label_OPCODE_LOAD_FN2: do {

 struct data *new_reference;
 pointer_t result_ptr;

 n_arguments = get_unaligned_32(&(ip + 1)[(0) * 2]);
 result_slot = get_unaligned_32(&(ip + 1)[(1) * 2]);
 direct_data = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->local_directory[get_unaligned_32(&(ip + 1)[(2) * 2])];
 indirect_data = pointer_empty();

 (ip += (1 + ((3) * 2)));

fn_copy_arguments_2:

 new_reference = u_data_alloc_function_reference_mayfail(n_arguments, &ajla_error , "./ipret-1.inc" ":" "1215");
 if ((__builtin_expect((int)(!new_reference), 0))) {
  function_error = u_thunk_alloc_exception_error(ajla_error, ((void*)0), fp, ip , "./ipret-1.inc" ":" "1217");
  if (!direct_data)
   u_pointer_dereference_(indirect_data , "./ipret-1.inc" ":" "1219");

  ip = free_parameters_2(fp, ip, n_arguments);
  result_ptr = pointer_thunk(function_error);
 } else {
  arg_t i;
  if (direct_data) {
   ((((void)(zero_()))), &(new_reference)->u_.function_reference)->is_indirect = 0;
   ((((void)(zero_()))), &(new_reference)->u_.function_reference)->u.direct = direct_data;
  } else {
   ((((void)(zero_()))), &(new_reference)->u_.function_reference)->is_indirect = 1;
   ((((void)(zero_()))), &(new_reference)->u_.function_reference)->u.indirect = indirect_data;
  }
  for (i = 0; i < n_arguments; i++) {
   u_ipret_fill_function_reference_from_slot(new_reference, i, fp, get_unaligned_32(&(ip)[(0) * 2]), (get_unaligned_32(&(ip)[(1) * 2]) & 0x0002) != 0);
   (ip += (((2) * 2)));
  }
  result_ptr = pointer_data(new_reference);
 }

 frame_set_pointer(fp, result_slot, result_ptr);

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CURRY2: do {

 frame_t fn_ref_slot;

 n_arguments = get_unaligned_32(&(ip + 1)[(0) * 2]);
 result_slot = get_unaligned_32(&(ip + 1)[(1) * 2]);

 fn_ref_slot = get_unaligned_32(&(ip + 1)[(2) * 2]);
 direct_data = ((void*)0);
 indirect_data = frame_get_pointer_reference(fp, fn_ref_slot, (get_unaligned_32(&(ip + 1)[(3) * 2]) & 0x0002) != 0);

 (ip += (1 + ((4) * 2)));

 goto fn_copy_arguments_2;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

}

{ arg_t n_arguments; arg_t n_return_values; struct thunk *function_error; struct data *function; const code_t *orig_ip; frame_s *new_fp; arg_t i; pointer_t *direct_function; pointer_t indirect_function; unsigned char mode;
# 1274 "./ipret-1.inc"
label_OPCODE_CALL2: do {

 pointer_t *function_ptr;

 mode = 1;
call_from_mode_2:

 n_arguments = get_unaligned_32(&(ip + 1)[(0) * 2]);
 n_return_values = get_unaligned_32(&(ip + 1)[(1) * 2]);
 function_ptr = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->local_directory[get_unaligned_32(&(ip + 1)[(2) * 2])];

 do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(function_ptr); else p_ = *(function_ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (function) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1291"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(function_ptr, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(function_ptr) , "./ipret-1.inc" ":" "1291"); { function_error = thunk_; thunk_reference(function_error); (ip += (1 + ((3) * 2))); goto call_set_error_2;; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);







 ((void)(zero_()));





 (ip += (1 + ((3) * 2)));

 new_fp = frame_build(fp, function, &ajla_error);
 if ((__builtin_expect((int)(!new_fp), 0))) {
call_allocation_error_2:
  function_error = u_thunk_alloc_exception_error(ajla_error, ((void*)0), fp, ip , "./ipret-1.inc" ":" "1304");
call_set_error_2:
  ip = free_parameters_2(fp, ip, n_arguments);
  pointer_reference_owned_multiple(pointer_thunk(function_error), n_return_values - 1);
  i = n_return_values;
  while (1) {
   frame_t slot_r = get_unaligned_32(&(ip)[(0) * 2]);
   (ip += (((1) * 2) + 1));
   frame_set_pointer(fp, slot_r, pointer_thunk(function_error));
   if (!--i)
    break;
  }
 } else {
  fp = frame_up(new_fp);
  frame_init(new_fp, function, (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->timestamp, mode);

  i = 0;
call_copy_arguments_2:
  for (; i < ((((void)(zero_()))), &(function)->u_.function)->n_arguments; i++) {
   frame_t src_slot = get_unaligned_32(&(ip)[(0) * 2]);
   frame_t dst_slot = ((((void)(zero_()))), &(function)->u_.function)->args[i].slot;
   unsigned char src_flag = (unsigned char)get_unaligned_32(&(ip)[(1) * 2]);
   _Bool may_be_borrowed = ((((void)(zero_()))), &(function)->u_.function)->args[i].may_be_borrowed;
   if (may_be_borrowed && src_flag & 0x0004 && !pointer_is_thunk(*(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(src_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))))) {
    *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(new_fp))) + ((size_t)(dst_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(src_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
   } else if (may_be_borrowed && src_flag & 0x0008 && !frame_test_flag(fp, src_slot) && !pointer_is_thunk(*(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(src_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))))) {
    *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(new_fp))) + ((size_t)(dst_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(src_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
    *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(src_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = pointer_empty();
   } else {
    u_ipret_copy_variable(fp, src_slot, new_fp, dst_slot, (src_flag & 0x0002) != 0);
   }
   (ip += (((2) * 2)));
  }
  (((struct frame_struct *)(void *)(((const char *)(void *)(new_fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->previous_ip = frame_ip(fp, ip);

  fp = new_fp;
  ip = &((((void)(zero_()))), &(function)->u_.function)->code[0];

  if ((__builtin_expect((int)(mode == 3), 0))) {
   do { void *ex_ = u_ipret_tick(fp, ip); do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } while (0);
  }
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_STRICT2: do {

 mode = 2;
 goto call_from_mode_2;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_SPARK2: do {

 mode = 3;
 goto call_from_mode_2;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_INDIRECT2: do {

 frame_t fn_ref_slot;
 _Bool deref;
 pointer_t *ptr;

 mode = 1;
call_indirect_from_mode_2:

 orig_ip = ip;
 n_arguments = get_unaligned_32(&(ip + 1)[(0) * 2]);
 n_return_values = get_unaligned_32(&(ip + 1)[(1) * 2]);
 fn_ref_slot = get_unaligned_32(&(ip + 1)[(2) * 2]);
 deref = (get_unaligned_32(&(ip + 1)[(3) * 2]) & 0x0002) != 0;
 (ip += (1 + ((4) * 2)));

 ptr = (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(fn_ref_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
 while (1) {
  do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(ptr); else p_ = *(ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (function) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1388"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(ptr, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(ptr) , "./ipret-1.inc" ":" "1388"); { function_error = thunk_; thunk_reference(function_error); if (deref) frame_free_and_clear(fp, fn_ref_slot); goto call_set_error_2; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, orig_ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);







  if (!((((void)(zero_()))), &(function)->u_.function_reference)->is_indirect)
   break;
  ptr = &((((void)(zero_()))), &(function)->u_.function_reference)->u.indirect;
 }
 ptr = ((((void)(zero_()))), &(function)->u_.function_reference)->u.direct;
 do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(ptr); else p_ = *(ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (function) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1401"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(ptr, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(ptr) , "./ipret-1.inc" ":" "1401"); { function_error = thunk_; thunk_reference(function_error); if (deref) frame_free_and_clear(fp, fn_ref_slot); goto call_set_error_2; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, orig_ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);
# 1403 "./ipret-1.inc"
 new_fp = frame_build(fp, function, &ajla_error);
 if ((__builtin_expect((int)(!new_fp), 0))) {
  if (deref)
   frame_free_and_clear(fp, fn_ref_slot);
  goto call_allocation_error_2;
 } else {
  fp = frame_up(new_fp);
  frame_init(new_fp, function, (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->timestamp, mode);

  i = ((((void)(zero_()))), &(function)->u_.function)->n_arguments - n_arguments;

  u_copy_from_function_reference_to_frame(new_fp, pointer_get_data_(*(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(fn_ref_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) , "./ipret-1.inc" ":" "1414"), i, deref && frame_test_flag(fp, fn_ref_slot));
  if (deref)
   frame_free_and_clear(fp, fn_ref_slot);

  goto call_copy_arguments_2;
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_INDIRECT_STRICT2: do {

 mode = 2;
 goto call_indirect_from_mode_2;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_INDIRECT_SPARK2: do {

 mode = 3;
 goto call_indirect_from_mode_2;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_LAZY2: do {

 struct data *function_reference;
 struct thunk **results;

 n_arguments = get_unaligned_32(&(ip + 1)[(0) * 2]);
 n_return_values = get_unaligned_32(&(ip + 1)[(1) * 2]);
 direct_function = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->local_directory[get_unaligned_32(&(ip + 1)[(2) * 2])];
 indirect_function = pointer_empty();

 (ip += (1 + ((3) * 2)));

call_lazy_copy_arguments_2:
 results = ((__builtin_expect((int)(!mem_check_overflow(0, n_return_values, sizeof(struct thunk *), &ajla_error)), 0)) ? ((struct thunk **)(void *)(((void*)0))) : ((struct thunk **)(void *)(mem_alloc_position((((size_t)(0) + (size_t)(n_return_values) * (size_t)(sizeof(struct thunk *))) >= ((size_t)(0)) + (zero_()) ? ((size_t)(0) + (size_t)(n_return_values) * (size_t)(sizeof(struct thunk *))) : ((size_t)(0))), &ajla_error , "./ipret-1.inc" ":" "1450"))));
 if ((__builtin_expect((int)(!results), 0))) {
  if (!direct_function)
   u_pointer_dereference_(indirect_function , "./ipret-1.inc" ":" "1453");
  goto call_allocation_error_2;
 }

 if (!(function_reference = u_data_alloc_function_reference_mayfail(n_arguments, &ajla_error , "./ipret-1.inc" ":" "1457"))) {
  if (!direct_function)
   u_pointer_dereference_(indirect_function , "./ipret-1.inc" ":" "1459");
  mem_free_position(results , "./ipret-1.inc" ":" "1460");
  goto call_allocation_error_2;
 }
 if (direct_function) {
  ((((void)(zero_()))), &(function_reference)->u_.function_reference)->is_indirect = 0;
  ((((void)(zero_()))), &(function_reference)->u_.function_reference)->u.direct = direct_function;
 } else {
  ((((void)(zero_()))), &(function_reference)->u_.function_reference)->is_indirect = 1;
  ((((void)(zero_()))), &(function_reference)->u_.function_reference)->u.indirect = indirect_function;
 }

 if (!u_thunk_alloc_function_call(pointer_data(function_reference), n_return_values, results, &ajla_error)) {
  if (!direct_function)
   u_pointer_dereference_(indirect_function , "./ipret-1.inc" ":" "1473");
  mem_free_position(results , "./ipret-1.inc" ":" "1474");
  do { ((void)(zero_())); do { refcount_poison_tag_(&(function_reference)->refcount_, "./ipret-1.inc" ":" "1475");; mem_free_aligned_position(data_untag_(function_reference, "./ipret-1.inc" ":" "1475") , "./ipret-1.inc" ":" "1475"); } while (0); } while (0);
  goto call_allocation_error_2;
 }

 for (i = 0; i < n_arguments; i++) {
  frame_t src_slot = get_unaligned_32(&(ip)[(0) * 2]);
  unsigned char src_flag = (unsigned char)get_unaligned_32(&(ip)[(1) * 2]);
  u_ipret_fill_function_reference_from_slot(function_reference, i, fp, src_slot, (src_flag & 0x0002) != 0);
  (ip += (((2) * 2)));
 }

 for (i = 0; i < n_return_values; i++) {
  frame_t slot_r = get_unaligned_32(&(ip)[(0) * 2]);
  frame_set_pointer(fp, slot_r, pointer_thunk(results[i]));
  (ip += (((1) * 2) + 1));
 }

 mem_free_position(results , "./ipret-1.inc" ":" "1492");

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_INDIRECT_LAZY2: do {

 frame_t fn_ref_slot;
 _Bool deref;

 n_arguments = get_unaligned_32(&(ip + 1)[(0) * 2]);
 n_return_values = get_unaligned_32(&(ip + 1)[(1) * 2]);
 fn_ref_slot = get_unaligned_32(&(ip + 1)[(2) * 2]);
 deref = (get_unaligned_32(&(ip + 1)[(3) * 2]) & 0x0002) != 0;
 (ip += (1 + ((4) * 2)));

 indirect_function = frame_get_pointer_reference(fp, fn_ref_slot, deref);
 direct_function = ((void*)0);

 goto call_lazy_copy_arguments_2;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_CACHE2: do {

 struct ipret_call_cache_arg *arguments;
 frame_t *return_values;
 void *ex;

call_cache_2:
 orig_ip = ip;
 n_arguments = get_unaligned_32(&(ip + 1)[(0) * 2]);
 n_return_values = get_unaligned_32(&(ip + 1)[(1) * 2]);
 direct_function = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->local_directory[get_unaligned_32(&(ip + 1)[(2) * 2])];
 (ip += (1 + ((3) * 2)));

 do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(direct_function); else p_ = *(direct_function); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (function) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1532"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(direct_function, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(direct_function) , "./ipret-1.inc" ":" "1532"); { function_error = thunk_; thunk_reference(function_error); goto call_set_error_2;; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, orig_ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);





 ((void)(zero_()));




 arguments = ((__builtin_expect((int)(!mem_check_overflow(0, n_arguments, sizeof(struct ipret_call_cache_arg), &ajla_error)), 0)) ? ((struct ipret_call_cache_arg *)(void *)(((void*)0))) : ((struct ipret_call_cache_arg *)(void *)(mem_alloc_position((((size_t)(0) + (size_t)(n_arguments) * (size_t)(sizeof(struct ipret_call_cache_arg))) >= ((size_t)(0)) + (zero_()) ? ((size_t)(0) + (size_t)(n_arguments) * (size_t)(sizeof(struct ipret_call_cache_arg))) : ((size_t)(0))), &ajla_error , "./ipret-1.inc" ":" "1538"))));
 if (!arguments) {
  goto call_allocation_error_2;
 }
 return_values = ((__builtin_expect((int)(!mem_check_overflow(0, n_return_values, sizeof(frame_t), &ajla_error)), 0)) ? ((frame_t *)(void *)(((void*)0))) : ((frame_t *)(void *)(mem_alloc_position((((size_t)(0) + (size_t)(n_return_values) * (size_t)(sizeof(frame_t))) >= ((size_t)(0)) + (zero_()) ? ((size_t)(0) + (size_t)(n_return_values) * (size_t)(sizeof(frame_t))) : ((size_t)(0))), &ajla_error , "./ipret-1.inc" ":" "1542"))));
 if (!return_values) {
  mem_free_position(arguments , "./ipret-1.inc" ":" "1544");
  goto call_allocation_error_2;
 }

 for (i = 0; i < n_arguments; i++) {
  frame_t src_slot = get_unaligned_32(&(ip)[(0) * 2]);
  unsigned char src_flag = (unsigned char)get_unaligned_32(&(ip)[(1) * 2]);
  arguments[i].f_arg = ((void*)0);
  arguments[i].slot = src_slot;
  arguments[i].deref = (src_flag & 0x0002) != 0;
  (ip += (((2) * 2)));
 }

 for (i = 0; i < n_return_values; i++) {
  frame_t slot_r = get_unaligned_32(&(ip)[(0) * 2]);
  return_values[i] = slot_r;
  (ip += (((1) * 2) + 1));
 }

 ex = u_ipret_call_cache(fp, orig_ip, direct_function, arguments, return_values, ((frame_t)-1));
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0))) {
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_SAVE2: do {

 goto call_cache_2;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_INDIRECT_CACHE2: do {

 struct ipret_call_cache_arg *arguments;
 frame_t *return_values;
 void *ex;

 frame_t fn_ref_slot;
 _Bool deref;
 pointer_t *ptr;
 arg_t n_curried_arguments;

call_indirect_cache_2:
 orig_ip = ip;
 n_arguments = get_unaligned_32(&(ip + 1)[(0) * 2]);
 n_return_values = get_unaligned_32(&(ip + 1)[(1) * 2]);
 fn_ref_slot = get_unaligned_32(&(ip + 1)[(2) * 2]);
 deref = (get_unaligned_32(&(ip + 1)[(3) * 2]) & 0x0002) != 0;
 (ip += (1 + ((4) * 2)));

 n_curried_arguments = 0;
 ptr = (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(fn_ref_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
 while (1) {
  do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(ptr); else p_ = *(ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (function) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1605"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(ptr, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(ptr) , "./ipret-1.inc" ":" "1605"); { function_error = thunk_; thunk_reference(function_error); if (deref) frame_free_and_clear(fp, fn_ref_slot); goto call_set_error_2; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, orig_ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);







  n_curried_arguments += ((((void)(zero_()))), &(function)->u_.function_reference)->n_curried_arguments;
  if (!((((void)(zero_()))), &(function)->u_.function_reference)->is_indirect)
   break;
  ptr = &((((void)(zero_()))), &(function)->u_.function_reference)->u.indirect;
 }
 ptr = ((((void)(zero_()))), &(function)->u_.function_reference)->u.direct;
 do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(ptr); else p_ = *(ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (function) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1619"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(ptr, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(ptr) , "./ipret-1.inc" ":" "1619"); { function_error = thunk_; thunk_reference(function_error); if (deref) frame_free_and_clear(fp, fn_ref_slot); goto call_set_error_2; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, orig_ip); } { do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);
# 1621 "./ipret-1.inc"
 arguments = ((__builtin_expect((int)(!mem_check_overflow(0, n_curried_arguments + n_arguments, sizeof(struct ipret_call_cache_arg), &ajla_error)), 0)) ? ((struct ipret_call_cache_arg *)(void *)(((void*)0))) : ((struct ipret_call_cache_arg *)(void *)(mem_alloc_position((((size_t)(0) + (size_t)(n_curried_arguments + n_arguments) * (size_t)(sizeof(struct ipret_call_cache_arg))) >= ((size_t)(0)) + (zero_()) ? ((size_t)(0) + (size_t)(n_curried_arguments + n_arguments) * (size_t)(sizeof(struct ipret_call_cache_arg))) : ((size_t)(0))), &ajla_error , "./ipret-1.inc" ":" "1621"))));
 if (!arguments) {
  if (deref)
   frame_free_and_clear(fp, fn_ref_slot);
  goto call_allocation_error_2;
 }
 return_values = ((__builtin_expect((int)(!mem_check_overflow(0, n_return_values, sizeof(frame_t), &ajla_error)), 0)) ? ((frame_t *)(void *)(((void*)0))) : ((frame_t *)(void *)(mem_alloc_position((((size_t)(0) + (size_t)(n_return_values) * (size_t)(sizeof(frame_t))) >= ((size_t)(0)) + (zero_()) ? ((size_t)(0) + (size_t)(n_return_values) * (size_t)(sizeof(frame_t))) : ((size_t)(0))), &ajla_error , "./ipret-1.inc" ":" "1627"))));
 if (!return_values) {
  mem_free_position(arguments , "./ipret-1.inc" ":" "1629");
  if (deref)
   frame_free_and_clear(fp, fn_ref_slot);
  goto call_allocation_error_2;
 }

 i = n_curried_arguments;
 function = pointer_get_data_(*(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(fn_ref_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) , "./ipret-1.inc" ":" "1636");
 while (1) {
  arg_t j;
  j = ((((void)(zero_()))), &(function)->u_.function_reference)->n_curried_arguments;
  while (j--) {
   i--;
   arguments[i].f_arg = &((((void)(zero_()))), &(function)->u_.function_reference)->arguments[j];
   arguments[i].deref = 0;
  }
  if (!((((void)(zero_()))), &(function)->u_.function_reference)->is_indirect)
   break;
  function = pointer_get_data_(((((void)(zero_()))), &(function)->u_.function_reference)->u.indirect , "./ipret-1.inc" ":" "1647");
 }

 for (i = n_curried_arguments; i < n_curried_arguments + n_arguments; i++) {
  frame_t src_slot = get_unaligned_32(&(ip)[(0) * 2]);
  unsigned char src_flag = (unsigned char)get_unaligned_32(&(ip)[(1) * 2]);
  arguments[i].f_arg = ((void*)0);
  arguments[i].slot = src_slot;
  arguments[i].deref = (src_flag & 0x0002) != 0;
  (ip += (((2) * 2)));
 }

 for (i = 0; i < n_return_values; i++) {
  frame_t slot_r = get_unaligned_32(&(ip)[(0) * 2]);
  return_values[i] = slot_r;
  (ip += (((1) * 2) + 1));
 }

 ex = u_ipret_call_cache(fp, orig_ip, ptr, arguments, return_values, deref ? fn_ref_slot : ((frame_t)-1));
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0))) {
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_CALL_INDIRECT_SAVE2: do {

 goto call_indirect_cache_2;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

}

label_OPCODE_RETURN2: do {

 struct data *function;
 frame_s *previous_fp;
 const code_t *previous_ip;
 arg_t i, n;



 function = (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function;
 previous_fp = frame_up(fp);
 if ((__builtin_expect((int)(frame_is_top(previous_fp)), 0))) {
  struct execution_control *ex;
  void *exx;
  struct thunk *t;
  struct stack_bottom *sb = frame_stack_bottom(previous_fp);
  ex = sb->ex;
  if (!ex) {
   frame_t src_slot = get_unaligned_32(&(ip + 1)[(0) * 2]);
   sb->ret = u_ipret_copy_variable_to_pointer(fp, src_slot, 1);
   goto exit_ipret;
  }
  t = ex->thunk;
  n = ((((void)(zero_()))), &(function)->u_.function)->n_return_values;
  i = 0;
  do {
   frame_t src_slot = get_unaligned_32(&(ip + 1)[(i * 2) * 2]);
   frame_t flags = get_unaligned_32(&(ip + 1)[(i * 2 + 1) * 2]);
   t->u.function_call.results[i].ptr = u_ipret_copy_variable_to_pointer(fp, src_slot, (flags & 0x0002) != 0);
  } while (++i < n);
  exx = u_thunk_terminate(t, n);





  do { if ((exx) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((exx)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((exx)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 }

 (((struct frame_struct *)(void *)(((const char *)(void *)(previous_fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->timestamp = (((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->timestamp;
 previous_ip = &((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(previous_fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code[(((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->previous_ip];

 n = ((((void)(zero_()))), &(function)->u_.function)->n_return_values;
 i = 0;
 do {
  frame_t src_slot, dst_slot, flags;
  src_slot = get_unaligned_32(&(ip + 1)[(i * 2) * 2]);
  flags = get_unaligned_32(&(ip + 1)[(i * 2 + 1) * 2]);
  dst_slot = (frame_t)get_unaligned_32(&(previous_ip)[(0) * 2]);
  previous_ip += ((1) * 2) + 1;
  u_ipret_copy_variable(fp, src_slot, previous_fp, dst_slot, (flags & 0x0002) != 0);
 } while (++i < n);

 fp = previous_fp;
 ip = previous_ip;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


label_OPCODE_STRUCTURED2: do {

 const code_t *orig_ip = ip;

 frame_t struc, elem;
 pointer_t *struc_ptr;
 unsigned char *struc_flat;
 const struct type *t;
 _Bool optimize_elem_is_flat;

 unsigned char type;
 frame_t arg;

 pointer_t thunk_ptr;

 elem = get_unaligned_32(&(ip + 1)[(1) * 2]);
 optimize_elem_is_flat = frame_variable_is_flat(fp, elem);

structured_retry_2:
 struc = get_unaligned_32(&(ip + 1)[(0) * 2]);
 (ip += (1 + ((2) * 2)));

 t = frame_get_type_of_local(fp, struc);
 if (frame_variable_is_flat(fp, struc)) {
  if (!optimize_elem_is_flat) {
   frame_set_pointer(fp, struc, u_flat_to_data(frame_get_type_of_local(fp, struc), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(struc) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))));
   struc_flat = ((void*)0);
   struc_ptr = (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(struc) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
  } else {
   struc_flat = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(struc) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))));
   struc_ptr = ((void*)0);
  }
 } else {
  struc_flat = ((void*)0);
  struc_ptr = (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(struc) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
 }

 do {
  array_index_t array_index = (((uint64_t)(-((uint64_t)1 << (8 * sizeof(uint64_t) - 2)) * 2)));
  struct data *data = ((void*)0);

  type = (unsigned char)get_unaligned_32(&(ip)[(0) * 2]);
  arg = get_unaligned_32(&(ip)[(1) * 2]);
  (ip += (((3) * 2)));

  if ((type & 0x0f) == 0x03) {
   void *ex = u_ipret_get_index(fp, orig_ip, fp, arg, ((void*)0), &array_index, &thunk_ptr , "./ipret-1.inc" ":" "1786");
   if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0))) {
    if (ex == ((void *)(uintptr_t)2))
     goto structured_error_2;
    do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
   }
  }

  if (struc_flat) {
   switch (type & 0x0f) {
    case 0x01: {
     const struct flat_record_definition_entry *e;
     ((void)(zero_()));
     e = &(((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1799", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->entries[arg];
     t = e->subtype;
     struc_flat += e->flat_offset;
     break;
    }
    case 0x02: {
     thunk_ptr = u_pointer_error(error_ajla_aux_(1, 10, 0 , "./ipret-1.inc" ":" "1805"), fp, ip , "./ipret-1.inc" ":" "1805");
     goto structured_error_2;
    }
    case 0x03: {
     if ((__builtin_expect((int)(index_ge_int_(array_index, (((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 4)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1809", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 4))), ((void)sizeof(&(((struct flat_array_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_array_definition, type)))))->type == (t)), (((struct flat_array_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_array_definition, type)))))))->n_elements , "./ipret-1.inc" ":" "1809")), 0))) {
      index_free_(&array_index , "./ipret-1.inc" ":" "1810");
      thunk_ptr = u_pointer_error(error_ajla_aux_(1, 9, 0 , "./ipret-1.inc" ":" "1811"), fp, ip , "./ipret-1.inc" ":" "1811");
      goto structured_error_2;
     }
     t = (((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 4)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1814", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 4))), ((void)sizeof(&(((struct flat_array_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_array_definition, type)))))->type == (t)), (((struct flat_array_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_array_definition, type)))))))->base;
     struc_flat += t->size * index_to_int_(array_index , "./ipret-1.inc" ":" "1815");
     index_free_(&array_index , "./ipret-1.inc" ":" "1816");
     break;
    }
    default:
     internal("./ipret-1.inc" ":" "1820", "structured flat: invalid structure type %02x", type);
   }
  } else {
structured_restart_pointer_follow_2:
   do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(struc_ptr); else p_ = *(struc_ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (data) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "1831"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(struc_ptr, ((0)) >= 0 ? &frame_execution_control(fp)->wait[((0)) & 1] : ((0)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(struc_ptr) , "./ipret-1.inc" ":" "1831"); { if ((type & 0x0f) == 0x03) index_free_(&array_index , "./ipret-1.inc" ":" "1829"); goto structured_read_to_the_end_2;; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((0)) >= 0 && !(((0)) & 2)) { u_pointer_follow_wait(fp, orig_ip); } { if ((type & 0x0f) == 0x03) index_free_(&array_index , "./ipret-1.inc" ":" "1826"); do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);







   if ((__builtin_expect((int)(!data_is_writable(data)), 0))) {
    u_struct_clone(struc_ptr);
    goto structured_restart_pointer_follow_2;
   }
   switch (type & 0x0f) {
    case 0x01: {
     const struct record_definition *def = (((__builtin_expect((int)((((((void)(zero_()))), &(data)->u_.record)->definition)->tag == ((((0 + 2 * 5) + 5) + 4) + 2)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1838", "type_def: invalid type tag %u, expected %u", (((((void)(zero_()))), &(data)->u_.record)->definition)->tag, ((((0 + 2 * 5) + 5) + 4) + 2))), ((void)sizeof(&(((struct record_definition *)(void *)((((char *)(void *)((((((void)(zero_()))), &(data)->u_.record)->definition))) - __builtin_offsetof(struct record_definition, type)))))->type == (((((void)(zero_()))), &(data)->u_.record)->definition)), (((struct record_definition *)(void *)((((char *)(void *)((((((void)(zero_()))), &(data)->u_.record)->definition))) - __builtin_offsetof(struct record_definition, type)))))));
     ((void)(zero_()));
     t = def->types[arg];
     struc_ptr = (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(da_record_frame(data)))) + ((size_t)(arg) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));

     if (type & 0x20) {
      if (frame_variable_is_flat(fp, elem)) {
       if (((((((void)(zero_())), ((t)->tag) < 0 + 2 * 5) || (((void)(zero_())), ((t)->tag) >= ((0 + 2 * 5) + 5) && ((t)->tag) < ((0 + 2 * 5) + 5) + 4) || (((void)(zero_())), ((t)->tag) >= (0 + 2 * 5) && ((t)->tag) < (0 + 2 * 5) + 5) || ((t)->tag) == ((((0 + 2 * 5) + 5) + 4) + 0)) || ((t)->tag) == ((((0 + 2 * 5) + 5) + 4) + 3) || ((t)->tag) == ((((0 + 2 * 5) + 5) + 4) + 4)))) {
        frame_free(da_record_frame(data), arg);
        struc_flat = (((unsigned char *)(void *)(((((unsigned char *)(void *)(da_record_frame(data)))) + ((size_t)(arg) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))));
        goto structured_write_flat_2;
       }
      } else {
       if (!frame_test_and_set_flag(da_record_frame(data), arg))
        goto structured_write_ptr_2;
      }
     }

     if (!frame_test_flag(da_record_frame(data), arg)) {
      struc_flat = (((unsigned char *)(void *)(((((unsigned char *)(void *)(da_record_frame(data)))) + ((size_t)(arg) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))));
      if ((__builtin_expect((int)(!optimize_elem_is_flat), 0))) {
       frame_set_pointer(da_record_frame(data), arg, u_flat_to_data(t, struc_flat));
       struc_flat = ((void*)0);
      }
     }
     break;
    }
    case 0x02: {
     if ((__builtin_expect((int)(((((void)(zero_()))), &(data)->u_.option)->option != arg), 0))) {
      if ((__builtin_expect((int)((type & 0x20) != 0), 1))) {
       ((((void)(zero_()))), &(data)->u_.option)->option = arg;
      } else {
       thunk_ptr = u_pointer_error(error_ajla_aux_(1, 10, 0 , "./ipret-1.inc" ":" "1870"), fp, ip , "./ipret-1.inc" ":" "1870");
structured_error_2:
       if (struc_flat) {
        u_pointer_dereference_(thunk_ptr , "./ipret-1.inc" ":" "1873");
        optimize_elem_is_flat = 0;
        ip = orig_ip;
        goto structured_retry_2;
       } else {
        u_pointer_dereference_(*struc_ptr , "./ipret-1.inc" ":" "1878");
        *struc_ptr = thunk_ptr;
        goto structured_read_to_the_end_2;
       }
      }
     }
     struc_ptr = &((((void)(zero_()))), &(data)->u_.option)->pointer;
     break;
    }
    case 0x03: {
     unsigned array_flags;
     if ((__builtin_expect((int)((((void)(zero_())), (refcount_tag_get((const refcount_t *)&(data)->refcount_))) == 10), 0))) {
      array_index_t len_first;

      if (u_array_incomplete_collapse(struc_ptr))
       goto structured_restart_pointer_follow_2;

      len_first = u_array_len(pointer_get_data_(((((void)(zero_()))), &(data)->u_.array_incomplete)->first , "./ipret-1.inc" ":" "1895"));
      if (!index_ge_index_(array_index, len_first , "./ipret-1.inc" ":" "1896")) {
       index_free_(&len_first , "./ipret-1.inc" ":" "1897");
       struc_ptr = &((((void)(zero_()))), &(data)->u_.array_incomplete)->first;
       goto structured_restart_pointer_follow_2;
      } else {
       index_sub_(&array_index, len_first , "./ipret-1.inc" ":" "1901");
       index_free_(&len_first , "./ipret-1.inc" ":" "1902");
       struc_ptr = &((((void)(zero_()))), &(data)->u_.array_incomplete)->next;
       goto structured_restart_pointer_follow_2;
      }
     }
     if (!optimize_elem_is_flat) {
      array_flags = 2;
     } else if (type & 0x20) {
      array_flags = 1;
      t = frame_get_type_of_local(fp, elem);
     } else {
      array_flags = 0;
     }
     if ((__builtin_expect((int)(!u_array_modify(struc_ptr, array_index, array_flags, &struc_ptr, &struc_flat, &t, fp, ip)), 0))) {
      goto structured_read_to_the_end_2;
     }
     break;
    }
    default:
     internal("./ipret-1.inc" ":" "1921", "structured: invalid structure type %02x", type);
   }
  }
 } while (!(type & 0x20));
 if (struc_flat) {
structured_write_flat_2:
  memcpy_fast(struc_flat, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(elem) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), frame_get_type_of_local(fp, elem)->size);
 } else {

  if ((__builtin_expect((int)(!pointer_is_empty(*struc_ptr)), 1)))
   u_pointer_dereference_(*struc_ptr , "./ipret-1.inc" ":" "1931");
  if (frame_variable_is_flat(fp, elem)) {
   *struc_ptr = u_flat_to_data(frame_get_type_of_local(fp, elem), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(elem) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))));
  } else {
structured_write_ptr_2:
   *struc_ptr = frame_get_pointer_reference(fp, elem, (type & 0x10) != 0);
  }
 }
 if (0) {
  do {
   type = (unsigned char)get_unaligned_32(&(ip)[(0) * 2]);
   arg = get_unaligned_32(&(ip)[(1) * 2]);
   (ip += (((3) * 2)));
structured_read_to_the_end_2:;
  } while (!(type & 0x20));
  if (type & 0x10)
   frame_free(fp, elem);
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_RECORD_CREATE2: do {

 frame_t result_slot;
 arg_t n_entries, i, ii;
 const struct type *t;
 const struct record_definition *def;

 result_slot = get_unaligned_32(&(ip + 1)[(0) * 2]);
 n_entries = get_unaligned_32(&(ip + 1)[(1) * 2]);
 (ip += (1 + ((2) * 2)));

 t = frame_get_type_of_local(fp, result_slot);
 if (t->tag == ((((0 + 2 * 5) + 5) + 4) + 3)) {
  const code_t *backup_ip;
  def = (((__builtin_expect((int)(((((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1966", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->base)->tag == ((((0 + 2 * 5) + 5) + 4) + 2)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1966", "type_def: invalid type tag %u, expected %u", ((((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1966", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->base)->tag, ((((0 + 2 * 5) + 5) + 4) + 2))), ((void)sizeof(&(((struct record_definition *)(void *)((((char *)(void *)(((((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1966", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->base))) - __builtin_offsetof(struct record_definition, type)))))->type == ((((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1966", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->base)), (((struct record_definition *)(void *)((((char *)(void *)(((((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1966", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->base))) - __builtin_offsetof(struct record_definition, type)))))));
  backup_ip = ip;
  for (i = 0, ii = 0; i < n_entries; i++, ii++) {
   frame_t var_slot, record_slot;
   flat_size_t flat_offset;
   const struct type *flat_type;

   while ((__builtin_expect((int)(record_definition_is_elided(def, ii)), 0)))
    ii++;

   var_slot = get_unaligned_32(&(ip)[(0) * 2]);

   if ((__builtin_expect((int)(!frame_variable_is_flat(fp, var_slot)), 0))) {
    ip = backup_ip;
    goto create_record_no_flat_2;
   }
   record_slot = record_definition_slot(def, ii);
   flat_offset = (((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1983", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->entries[record_slot].flat_offset;
   flat_type = (((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1984", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->entries[record_slot].subtype;
   ((void)(zero_()));
   memcpy_fast((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(result_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))) + flat_offset, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(var_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), flat_type->size);
   (ip += (((2) * 2)));
  }
  ((void)(zero_()));
 } else {
  struct data *result;
  def = (((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 2)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "1992", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 2))), ((void)sizeof(&(((struct record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct record_definition, type)))))->type == (t)), (((struct record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct record_definition, type)))))));
create_record_no_flat_2:
  result = u_data_alloc_record_mayfail(def, &ajla_error , "./ipret-1.inc" ":" "1994");
  if ((__builtin_expect((int)(!result), 0))) {
   ip = free_parameters_2(fp, ip, n_entries);
   frame_set_pointer(fp, result_slot, u_pointer_error(ajla_error, fp, ip , "./ipret-1.inc" ":" "1997"));
   break;
  }
  memset(da_record_frame(result), 0, (((((frame_t)(def->n_slots)) + (1 << (( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((1 << (( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * ((frame_t)(def->n_slots)))) >> (( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) * ((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))));
  for (i = 0, ii = 0; i < n_entries; i++, ii++) {
   frame_t var_slot, record_slot;
   const struct type *rec_type, *var_type;

   while ((__builtin_expect((int)(record_definition_is_elided(def, ii)), 0)))
    ii++;

   var_slot = get_unaligned_32(&(ip)[(0) * 2]);
   record_slot = record_definition_slot(def, ii);
   rec_type = def->types[record_slot];
   var_type = frame_get_type_of_local(fp, var_slot);

   if (!frame_variable_is_flat(fp, var_slot)) {
    pointer_t ptr = frame_get_pointer_reference(fp, var_slot, (get_unaligned_32(&(ip)[(1) * 2]) & 0x0002) != 0);
    frame_set_pointer(da_record_frame(result), record_slot, ptr);
   } else if (((((((void)(zero_())), ((rec_type)->tag) < 0 + 2 * 5) || (((void)(zero_())), ((rec_type)->tag) >= ((0 + 2 * 5) + 5) && ((rec_type)->tag) < ((0 + 2 * 5) + 5) + 4) || (((void)(zero_())), ((rec_type)->tag) >= (0 + 2 * 5) && ((rec_type)->tag) < (0 + 2 * 5) + 5) || ((rec_type)->tag) == ((((0 + 2 * 5) + 5) + 4) + 0)) || ((rec_type)->tag) == ((((0 + 2 * 5) + 5) + 4) + 3) || ((rec_type)->tag) == ((((0 + 2 * 5) + 5) + 4) + 4)))) {
    ((void)(zero_()));
    memcpy_fast((((unsigned char *)(void *)(((((unsigned char *)(void *)(da_record_frame(result)))) + ((size_t)(record_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(var_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), rec_type->size);
   } else {
    pointer_t ptr = u_flat_to_data(var_type, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(var_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))));
    frame_set_pointer(da_record_frame(result), record_slot, ptr);
   }

   (ip += (((2) * 2)));
  }
  frame_set_pointer(fp, result_slot, pointer_data(result));
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_RECORD_LOAD2: do {

 frame_t record, record_slot, result;
 unsigned flags;
 const struct type *t;
 record = get_unaligned_32(&(ip + 1)[(0) * 2]);
 record_slot = get_unaligned_32(&(ip + 1)[(1) * 2]);
 result = get_unaligned_32(&(ip + 1)[(2) * 2]);
 flags = get_unaligned_32(&(ip + 1)[(3) * 2]);

 t = frame_get_type_of_local(fp, record);
 if (t->tag == ((((0 + 2 * 5) + 5) + 4) + 3) && !frame_test_flag(fp, record)) {
  const struct flat_record_definition_entry *ft = &(((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 3)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "2043", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 3))), ((void)sizeof(&(((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))->type == (t)), (((struct flat_record_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_record_definition, type)))))))->entries[record_slot];
  if ((__builtin_expect((int)(((((((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) < 0 + 2 * 5) || (((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) >= ((0 + 2 * 5) + 5) && ((frame_get_type_of_local(fp, result))->tag) < ((0 + 2 * 5) + 5) + 4) || (((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) >= (0 + 2 * 5) && ((frame_get_type_of_local(fp, result))->tag) < (0 + 2 * 5) + 5) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 0)) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 3) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 4)))), 1))) {
   memcpy_fast((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(result) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(record) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))) + ft->flat_offset, ft->subtype->size);
  } else {
   pointer_t ptr = u_flat_to_data(ft->subtype, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(record) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))) + ft->flat_offset);
   frame_set_pointer(fp, result, ptr);
  }
 } else {
  const struct type *rtype, *etype;
  struct data *data;
  frame_s *fr;
  do { pointer_t p_; if (!(1)) p_ = pointer_locked_read((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(record) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); else p_ = *((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(record) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (data) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "2064"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(record) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), ((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) >= 0 ? &frame_execution_control(fp)->wait[((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) & 1] : ((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(record) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))) , "./ipret-1.inc" ":" "2064"); { thunk_reference(thunk_); frame_set_pointer(fp, result, pointer_thunk(thunk_)); goto record_load_end_2;; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) >= 0 && !(((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) & 2)) { u_pointer_follow_wait(fp, ip); } { if (!(flags & 0x0001)) { ex_ = u_ipret_record_load_create_thunk(fp, ip, record, record_slot, result); if (ex_ == ((void *)(uintptr_t)3)) goto record_load_end_2; } do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);
# 2065 "./ipret-1.inc"
  rtype = ((((void)(zero_()))), &(data)->u_.record)->definition;
  etype = (((__builtin_expect((int)((rtype)->tag == ((((0 + 2 * 5) + 5) + 4) + 2)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "2066", "type_def: invalid type tag %u, expected %u", (rtype)->tag, ((((0 + 2 * 5) + 5) + 4) + 2))), ((void)sizeof(&(((struct record_definition *)(void *)((((char *)(void *)((rtype))) - __builtin_offsetof(struct record_definition, type)))))->type == (rtype)), (((struct record_definition *)(void *)((((char *)(void *)((rtype))) - __builtin_offsetof(struct record_definition, type)))))))->types[record_slot];
  fr = da_record_frame(data);
  if (!frame_test_flag(fr, record_slot)) {
    if ((__builtin_expect((int)(((((((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) < 0 + 2 * 5) || (((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) >= ((0 + 2 * 5) + 5) && ((frame_get_type_of_local(fp, result))->tag) < ((0 + 2 * 5) + 5) + 4) || (((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) >= (0 + 2 * 5) && ((frame_get_type_of_local(fp, result))->tag) < (0 + 2 * 5) + 5) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 0)) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 3) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 4)))), 1))) {
    memcpy_fast((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(result) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fr))) + ((size_t)(record_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), etype->size);
    } else {
    pointer_t ptr = u_flat_to_data(etype, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fr))) + ((size_t)(record_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))));
    frame_set_pointer(fp, result, ptr);
    }
  } else {
   u_pointer_reference_maybe_(fp, result, (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fr))) + ((size_t)(record_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), flags , "./ipret-1.inc" ":" "2076");
  }
 }

record_load_end_2:
 (ip += (1 + ((4) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_OPTION_CREATE_EMPTY_FLAT2: do {

 frame_t slot_r = get_unaligned_32(&(ip + 1)[(0) * 2]);
 ajla_flat_option_t opt = (ajla_flat_option_t)get_unaligned_32(&(ip + 1)[(1) * 2]);
 ((void)(zero_()));
 __asm__ volatile ("":::"memory");
 *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = opt;
 __asm__ volatile ("":::"memory");
 (ip += (1 + ((2) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_OPTION_CREATE_EMPTY2: do {

 struct data *d;
 frame_t slot_r;

 d = data_init_(((struct data *)(void *)(ptrcomp_verify(((void *)(void *)(mem_align_position((__builtin_offsetof(struct data, u_.option) + sizeof(((struct data *)((void*)0))->u_.option)), (((((uintptr_t)1 << 0) * 2)) >= (1) ? ((((uintptr_t)1 << 0) * 2)) : (1)), &ajla_error , "./ipret-1.inc" ":" "2102")))))), 4);
 slot_r = get_unaligned_32(&(ip + 1)[(0) * 2]);
 if ((__builtin_expect((int)(d != ((void*)0)), 1))) {
  ((((void)(zero_()))), &(d)->u_.option)->option = get_unaligned_32(&(ip + 1)[(1) * 2]);
  ((((void)(zero_()))), &(d)->u_.option)->pointer = pointer_empty();
  frame_set_pointer(fp, slot_r, pointer_data(d));
 } else {
  frame_set_pointer(fp, slot_r, u_pointer_error(ajla_error, fp, ip , "./ipret-1.inc" ":" "2109"));
 }
 (ip += (1 + ((2) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_OPTION_CREATE2: do {

 struct data *d;
 frame_t slot_1, slot_r;
 pointer_t ptr;

 slot_1 = get_unaligned_32(&(ip + 1)[(2) * 2]);
 if (!frame_variable_is_flat(fp, slot_1)) {
  ptr = frame_get_pointer_reference(fp, slot_1, (get_unaligned_32(&(ip + 1)[(3) * 2]) & 0x0002) != 0);
 } else {
  ptr = u_flat_to_data(frame_get_type_of_local(fp, slot_1), (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))));
 }

 d = data_init_(((struct data *)(void *)(ptrcomp_verify(((void *)(void *)(mem_align_position((__builtin_offsetof(struct data, u_.option) + sizeof(((struct data *)((void*)0))->u_.option)), (((((uintptr_t)1 << 0) * 2)) >= (1) ? ((((uintptr_t)1 << 0) * 2)) : (1)), &ajla_error , "./ipret-1.inc" ":" "2128")))))), 4);
 slot_r = get_unaligned_32(&(ip + 1)[(0) * 2]);
 if ((__builtin_expect((int)(d != ((void*)0)), 1))) {
  ((((void)(zero_()))), &(d)->u_.option)->option = get_unaligned_32(&(ip + 1)[(1) * 2]);
  ((((void)(zero_()))), &(d)->u_.option)->pointer = ptr;
  frame_set_pointer(fp, slot_r, pointer_data(d));
 } else {
  u_pointer_dereference_(ptr , "./ipret-1.inc" ":" "2135");
  frame_set_pointer(fp, slot_r, u_pointer_error(ajla_error, fp, ip , "./ipret-1.inc" ":" "2136"));
 }
 (ip += (1 + ((4) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_OPTION_LOAD2: do {

 frame_t option, option_idx, result;
 unsigned flags;
 struct data *data;
 pointer_t ptr;

 option = get_unaligned_32(&(ip + 1)[(0) * 2]);
 option_idx = get_unaligned_32(&(ip + 1)[(1) * 2]);
 result = get_unaligned_32(&(ip + 1)[(2) * 2]);
 flags = get_unaligned_32(&(ip + 1)[(3) * 2]);

 if ((__builtin_expect((int)(frame_variable_is_flat(fp, option)), 0)))
  goto option_load_mismatch2;

 do { pointer_t p_; if (!(1)) p_ = pointer_locked_read((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(option) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); else p_ = *((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(option) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (data) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "2167"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(option) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))), ((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) >= 0 ? &frame_execution_control(fp)->wait[((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) & 1] : ((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*((((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(option) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))) , "./ipret-1.inc" ":" "2167"); { thunk_reference(thunk_); frame_set_pointer(fp, result, pointer_thunk(thunk_)); goto option_load_end_2;; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) >= 0 && !(((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) & 2)) { u_pointer_follow_wait(fp, ip); } { if (!(flags & 0x0001)) { ex_ = u_ipret_option_load_create_thunk(fp, ip, option, option_idx, result); if (ex_ == ((void *)(uintptr_t)3)) goto option_load_end_2; } do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);
# 2169 "./ipret-1.inc"
 if ((__builtin_expect((int)(((((void)(zero_()))), &(data)->u_.option)->option != option_idx), 0))) {
option_load_mismatch2:
  ptr = u_pointer_error(error_ajla_aux_(1, 10, 0 , "./ipret-1.inc" ":" "2171"), fp, ip , "./ipret-1.inc" ":" "2171");
  frame_set_pointer(fp, result, ptr);
 } else {
  u_pointer_reference_maybe_(fp, result, &((((void)(zero_()))), &(data)->u_.option)->pointer, flags , "./ipret-1.inc" ":" "2174");
 }

option_load_end_2:
 (ip += (1 + ((4) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;


{ frame_t slot_1; ajla_option_t option;




label_OPCODE_OPTION_TEST_FLAT2: do {

 slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]);

 if (!frame_test_flag(fp, slot_1)) {
  __asm__ volatile ("":::"memory");
  option = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
  __asm__ volatile ("":::"memory");
  goto option_test_store_result_2;
 }
 goto option_test_2;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_OPTION_TEST2: do {

 frame_t slot_r;
 pointer_t ptr;
 struct data *data;

 slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]);
option_test_2:
 ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
 if ((__builtin_expect((int)(pointer_is_thunk(ptr)), 0))) {
  void *ex;
  ((void)(zero_()));
  ex = u_thunk_option_test(fp, ip, slot_1, get_unaligned_32(&(ip + 1)[(1) * 2]), get_unaligned_32(&(ip + 1)[(2) * 2]));
  if (ex == ((void *)(uintptr_t)3)) {
   (ip += (1 + ((3) * 2)));
   break;
  } else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) {
   do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
  }
  break;
 }
 data = pointer_get_data_(ptr , "./ipret-1.inc" ":" "2223");
 option = ((((void)(zero_()))), &(data)->u_.option)->option;
option_test_store_result_2:
 slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]);
 __asm__ volatile ("":::"memory");
 ((void)(zero_()));
 *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = option == (ajla_option_t)get_unaligned_32(&(ip + 1)[(1) * 2]);
 __asm__ volatile ("":::"memory");
 (ip += (1 + ((3) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_OPTION_ORD_FLAT2: do {

 slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]);

 if (!frame_test_flag(fp, slot_1)) {
  __asm__ volatile ("":::"memory");
  option = *(((ajla_flat_option_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
  __asm__ volatile ("":::"memory");
  goto option_ord_store_result_2;
 }
 goto option_ord_2;

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_OPTION_ORD2: do {

 frame_t slot_r;
 pointer_t ptr;
 struct data *data;

 slot_1 = get_unaligned_32(&(ip + 1)[(0) * 2]);
option_ord_2:
 ptr = *(((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_1) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
 if ((__builtin_expect((int)(pointer_is_thunk(ptr)), 0))) {
  void *ex;
  ((void)(zero_()));
  ex = u_thunk_option_ord(fp, ip, slot_1, get_unaligned_32(&(ip + 1)[(1) * 2]));
  if (ex == ((void *)(uintptr_t)3)) {
   (ip += (1 + ((2) * 2)));
   break;
  } else if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)1)), 0))) {
   do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
  }
  break;
 }
 data = pointer_get_data_(ptr , "./ipret-1.inc" ":" "2270");
 option = ((((void)(zero_()))), &(data)->u_.option)->option;
option_ord_store_result_2:
 slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]);
 __asm__ volatile ("":::"memory");
 ((void)(zero_()));
 *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(slot_r) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))))))))) = option;
 __asm__ volatile ("":::"memory");
 (ip += (1 + ((2) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

}


label_OPCODE_ARRAY_CREATE2: do {

 frame_t result_slot;
 size_t n_entries;
 struct data *total;

 result_slot = get_unaligned_32(&(ip + 1)[(0) * 2]);
 n_entries = get_unaligned_32(&(ip + 1)[(1) * 2]);
 (ip += (1 + ((2) * 2)));

 ((void)(zero_()));

 total = ((void*)0);
 while (1) {
  size_t n, i;
  struct data *a;
  const struct type *type = frame_get_type_of_local(fp, get_unaligned_32(&(ip)[(0) * 2]));
  _Bool flat = frame_variable_is_flat(fp, get_unaligned_32(&(ip)[(0) * 2]));
  for (n = 1; n < n_entries; n++) {
   if (frame_variable_is_flat(fp, get_unaligned_32(&(ip)[(n * 2) * 2])) != flat)
    break;
   if ((__builtin_expect((int)((int64_t)(n + 1) < (zero_())), 0)))
    break;
  }
  do {
   if (flat)
    a = u_data_alloc_array_flat_mayfail(type, n, n, 0, &ajla_error , "./ipret-1.inc" ":" "2311");
   else
    a = u_data_alloc_array_pointers_mayfail(n, n, &ajla_error , "./ipret-1.inc" ":" "2313");
  } while ((__builtin_expect((int)(!a), 0)) && (n >>= 1));
  if ((__builtin_expect((int)(!a), 0))) {
   if (total)
    data_dereference(total);
   goto array_create_error_2;
  }
  n_entries -= n;
  if (flat) {
   unsigned char *flat_ptr = da_array_flat(a);
   for (i = 0; i < n; i++) {
    frame_t var_slot = get_unaligned_32(&(ip)[(0) * 2]);
    memcpy_fast(flat_ptr, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(var_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), type->size);
    flat_ptr += type->size;
    (ip += (((2) * 2)));
   }
  } else {
   for (i = 0; i < n; i++) {
    frame_t var_slot = get_unaligned_32(&(ip)[(0) * 2]);
    pointer_t ptr = frame_get_pointer_reference(fp, var_slot, (get_unaligned_32(&(ip)[(1) * 2]) & 0x0002) != 0);
    ((((void)(zero_()))), &(a)->u_.array_pointers)->pointer[i] = ptr;
    (ip += (((2) * 2)));
   }
  }
  if ((__builtin_expect((int)(!total), 1))) {
   total = a;
  } else {
   total = u_array_join(total, a, &ajla_error);
   if ((__builtin_expect((int)(!total), 0))) {
array_create_error_2:
    ip = free_parameters_2(fp, ip, n_entries);
    frame_set_pointer(fp, result_slot, u_pointer_error(ajla_error, fp, ip , "./ipret-1.inc" ":" "2344"));
    break;
   }
  }
  if ((__builtin_expect((int)(!n_entries), 1))) {
   frame_set_pointer(fp, result_slot, pointer_data(total));
   break;
  }
 }

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_CREATE_EMPTY_FLAT2: do {

 frame_t result_slot;
 struct data *a;
 const struct type *type = da_type((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function, get_unaligned_32(&(ip + 1)[(1) * 2]));
 ((void)(zero_()));

 a = u_data_alloc_array_flat_mayfail(type, 0, 0, 0, &ajla_error , "./ipret-1.inc" ":" "2363");
 result_slot = get_unaligned_32(&(ip + 1)[(0) * 2]);
 frame_set_pointer(fp, result_slot, (__builtin_expect((int)(a != ((void*)0)), 1)) ? pointer_data(a) : u_pointer_error(ajla_error, fp, ip , "./ipret-1.inc" ":" "2365"));
 (ip += (1 + ((2) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_CREATE_EMPTY2: do {

 frame_t result_slot;
 struct data *a;

 a = u_data_alloc_array_pointers_mayfail(0, 0, &ajla_error , "./ipret-1.inc" ":" "2375");
 result_slot = get_unaligned_32(&(ip + 1)[(0) * 2]);
 frame_set_pointer(fp, result_slot, (__builtin_expect((int)(a != ((void*)0)), 1)) ? pointer_data(a) : u_pointer_error(ajla_error, fp, ip , "./ipret-1.inc" ":" "2377"));
 (ip += (1 + ((1) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_FILL2: do {

 frame_t content_slot, length_slot, result_slot;
 unsigned char content_flag;
 array_index_t length;
 pointer_t result_ptr;
 void *ex;

 content_slot = get_unaligned_32(&(ip + 1)[(0) * 2]);
 content_flag = get_unaligned_32(&(ip + 1)[(1) * 2]);
 length_slot = get_unaligned_32(&(ip + 1)[(2) * 2]);
 result_slot = get_unaligned_32(&(ip + 1)[(3) * 2]);

 ex = u_ipret_get_index(fp, ip, fp, length_slot, ((void*)0), &length, &result_ptr , "./ipret-1.inc" ":" "2395");
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0))) {
  if (ex == ((void *)(uintptr_t)2)) {
   if (content_flag & 0x0002)
    frame_free_and_clear(fp, content_slot);
   goto array_fill_error_2;
  }
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
 }

 if (!frame_variable_is_flat(fp, content_slot)) {
  pointer_t ptr = frame_get_pointer_reference(fp, content_slot, (content_flag & 0x0002) != 0);
  if ((__builtin_expect((int)((content_flag & 0x0004) != 0), 0))) {
   result_ptr = u_array_create_sparse(length, ptr);
  } else {
   result_ptr = u_array_create(length, ((void*)0), ((void*)0), ptr);
  }
 } else {
  const struct type *type = frame_get_type_of_local(fp, content_slot);
  __asm__ volatile ("":::"memory");
  if ((__builtin_expect((int)((content_flag & 0x0004) != 0), 0)) && (__builtin_expect((int)(index_ge_int_(length, 1 , "./ipret-1.inc" ":" "2415")), 1))) {
   pointer_t ptr = u_flat_to_data(type, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(content_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))));
   result_ptr = u_array_create_sparse(length, ptr);
  } else {
   if (((((((void)(zero_())), ((frame_get_type_of_local(fp, result_slot))->tag) < 0 + 2 * 5) || (((void)(zero_())), ((frame_get_type_of_local(fp, result_slot))->tag) >= ((0 + 2 * 5) + 5) && ((frame_get_type_of_local(fp, result_slot))->tag) < ((0 + 2 * 5) + 5) + 4) || (((void)(zero_())), ((frame_get_type_of_local(fp, result_slot))->tag) >= (0 + 2 * 5) && ((frame_get_type_of_local(fp, result_slot))->tag) < (0 + 2 * 5) + 5) || ((frame_get_type_of_local(fp, result_slot))->tag) == ((((0 + 2 * 5) + 5) + 4) + 0)) || ((frame_get_type_of_local(fp, result_slot))->tag) == ((((0 + 2 * 5) + 5) + 4) + 3) || ((frame_get_type_of_local(fp, result_slot))->tag) == ((((0 + 2 * 5) + 5) + 4) + 4)))) {
    unsigned char *result = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(result_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))))));
    int64_t l = index_to_int_(length , "./ipret-1.inc" ":" "2421");
    index_free_(&length , "./ipret-1.inc" ":" "2422");
    while (l--) {
     result = mempcpy(result, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(content_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), type->size);
    }
    goto array_exit_2;
   } else {
    result_ptr = u_array_create(length, type, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(content_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), pointer_empty());
   }
  }
  __asm__ volatile ("":::"memory");
 }

array_fill_error_2:
 frame_set_pointer(fp, result_slot, result_ptr);

array_exit_2:
 (ip += (1 + ((4) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_STRING2: do {

 frame_t result_slot, length;
 pointer_t result_ptr;

 result_slot = get_unaligned_32(&(ip + 1)[(0) * 2]);
 length = get_unaligned_32(&(ip + 1)[(1) * 2]);
 (ip += (1 + ((2) * 2)));

 if ((__builtin_expect((int)((int64_t)length < (int64_t)(zero_())), 0)) ||
     (__builtin_expect((int)((frame_t)(int64_t)length != length), 0))) {
  result_ptr = u_pointer_error(error_ajla_aux_(2, 3, 0 , "./ipret-1.inc" ":" "2453"), fp, ip , "./ipret-1.inc" ":" "2453");
 } else {
  result_ptr = u_array_string(length, type_get_fixed(0, 1), ((unsigned char *)(void *)(ip)));
 }
 frame_set_pointer(fp, result_slot, result_ptr);

 (ip += ((length + 1) >> 1));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_UNICODE2: do {

 frame_t result_slot, length;
 pointer_t result_ptr;

 result_slot = get_unaligned_32(&(ip + 1)[(0) * 2]);
 length = get_unaligned_32(&(ip + 1)[(1) * 2]);
 (ip += (1 + ((2) * 2)));

 if ((__builtin_expect((int)((int64_t)length < (int64_t)(zero_())), 0)) ||
     (__builtin_expect((int)((frame_t)(int64_t)length != length), 0))) {
  result_ptr = u_pointer_error(error_ajla_aux_(2, 3, 0 , "./ipret-1.inc" ":" "2474"), fp, ip , "./ipret-1.inc" ":" "2474");
 } else {
  result_ptr = u_array_string(length, type_get_int(2), ((unsigned char *)(void *)(ip)));
 }
 frame_set_pointer(fp, result_slot, result_ptr);

 (ip += (length * 2));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_LOAD2: do {

 frame_t array, idx, result;
 unsigned flags;
 const struct type *t, *t_elem;
 void *ex;
 array_index_t array_index;
 pointer_t ptr;
 unsigned char *flat;

 array = get_unaligned_32(&(ip + 1)[(0) * 2]);
 idx = get_unaligned_32(&(ip + 1)[(1) * 2]);
 result = get_unaligned_32(&(ip + 1)[(2) * 2]);
 flags = get_unaligned_32(&(ip + 1)[(3) * 2]);

 ex = u_ipret_get_index(fp, ip, fp, idx, ((void*)0), &array_index, &ptr , "./ipret-1.inc" ":" "2499");
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0))) {
  if (ex == ((void *)(uintptr_t)2))
   goto array_load_set_ptr_2;
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);
 }

 t = frame_get_type_of_local(fp, array);
 if (t->tag == ((((0 + 2 * 5) + 5) + 4) + 4) && !frame_test_flag(fp, array)) {
  const struct flat_array_definition *def = (((__builtin_expect((int)((t)->tag == ((((0 + 2 * 5) + 5) + 4) + 4)), 1)) ? (void)0 : internal ("./ipret-1.inc" ":" "2508", "type_def: invalid type tag %u, expected %u", (t)->tag, ((((0 + 2 * 5) + 5) + 4) + 4))), ((void)sizeof(&(((struct flat_array_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_array_definition, type)))))->type == (t)), (((struct flat_array_definition *)(void *)((((char *)(void *)((t))) - __builtin_offsetof(struct flat_array_definition, type)))))));
  if ((__builtin_expect((int)(index_ge_int_(array_index, def->n_elements , "./ipret-1.inc" ":" "2509")), 0))) {
   if ((__builtin_expect((int)((flags & 0x0004) != 0), 0)))
    internal("./ipret-1.inc" ":" "2511", "array_load: flat array index out of range");
   index_free_(&array_index , "./ipret-1.inc" ":" "2512");
   ptr = u_pointer_error(error_ajla_aux_(1, 9, 0 , "./ipret-1.inc" ":" "2513"), fp, ip , "./ipret-1.inc" ":" "2513");
   goto array_load_set_ptr_2;
  }
  t_elem = def->base;
  flat = (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(array) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))) + t_elem->size * index_to_int_(array_index , "./ipret-1.inc" ":" "2517");
  index_free_(&array_index , "./ipret-1.inc" ":" "2518");
  goto array_load_set_flat_2;
 } else {
  pointer_t *array_ptr = (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(array) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
  pointer_t *pptr;
  struct data *data;

array_restart_pointer_follow_2:
  do { pointer_t p_; if (!(0)) p_ = pointer_locked_read(array_ptr); else p_ = *(array_ptr); if ((__builtin_expect((int)(!pointer_is_thunk(p_)), 1))) { (data) = pointer_get_data_(p_ , "./ipret-1.inc" ":" "2538"); break; } else { void *ex__; ex__ = u_pointer_follow_thunk_(array_ptr, ((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) >= 0 ? &frame_execution_control(fp)->wait[((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) & 1] : ((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) == (-1) ? ((void*)0) : ((void *)(uintptr_t)1)); if (ex__ == ((void *)(uintptr_t)1)) continue; if (ex__ == ((void *)(uintptr_t)2)) { struct thunk __attribute__((__unused__)) *thunk_; thunk_ = pointer_get_thunk_(*(array_ptr) , "./ipret-1.inc" ":" "2538"); { index_free_(&array_index , "./ipret-1.inc" ":" "2534"); thunk_reference(thunk_); ptr = pointer_thunk(thunk_); goto array_load_set_ptr_2;; } not_reached(); } { struct execution_control __attribute__((__unused__)) *ex_; ex_ = ((struct execution_control *)(void *)(ex__)); if (((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) >= 0 && !(((__builtin_expect((int)(flags & 0x0001), 0)) ? (0) : (-1)) & 2)) { u_pointer_follow_wait(fp, ip); } { index_free_(&array_index , "./ipret-1.inc" ":" "2527"); if (!(flags & 0x0001)) { ex_ = u_ipret_array_load_create_thunk(fp, ip, array, idx, result); if (ex_ == ((void *)(uintptr_t)3)) goto array_load_end_2; } do { if ((ex_) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex_)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex_)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0); } not_reached(); } } } while (1);
# 2540 "./ipret-1.inc"
  if ((__builtin_expect((int)((((void)(zero_())), (refcount_tag_get((const refcount_t *)&(data)->refcount_))) == 10), 0))) {
   array_index_t len_first;

   if (array_ptr == (((pointer_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(array) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))))) {
    if (!frame_test_and_set_flag(fp, array))
     data_reference(data);
    if (u_array_incomplete_collapse(array_ptr))
     goto array_restart_pointer_follow_2;
   }

   len_first = u_array_len(pointer_get_data_(((((void)(zero_()))), &(data)->u_.array_incomplete)->first , "./ipret-1.inc" ":" "2550"));
   if (!index_ge_index_(array_index, len_first , "./ipret-1.inc" ":" "2551")) {
    index_free_(&len_first , "./ipret-1.inc" ":" "2552");
    data = pointer_get_data_(((((void)(zero_()))), &(data)->u_.array_incomplete)->first , "./ipret-1.inc" ":" "2553");
   } else {
    index_sub_(&array_index, len_first , "./ipret-1.inc" ":" "2555");
    index_free_(&len_first , "./ipret-1.inc" ":" "2556");
    array_ptr = &((((void)(zero_()))), &(data)->u_.array_incomplete)->next;
    goto array_restart_pointer_follow_2;
   }
  }

  if ((__builtin_expect((int)(!u_array_read(data, array_index, &pptr, &flat, &t_elem, ((void*)0))), 0))) {
   if ((__builtin_expect((int)((flags & 0x0004) != 0), 0)))
    internal("./ipret-1.inc" ":" "2564", "array_load: array index out of range");
   ptr = u_pointer_error(error_ajla_aux_(1, 9, 0 , "./ipret-1.inc" ":" "2565"), fp, ip , "./ipret-1.inc" ":" "2565");
   goto array_load_set_ptr_2;
  }
  if (pptr) {
   u_pointer_reference_maybe_(fp, result, pptr, flags , "./ipret-1.inc" ":" "2569");
   goto array_load_end_2;
  } else {
array_load_set_flat_2:
    if ((__builtin_expect((int)(((((((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) < 0 + 2 * 5) || (((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) >= ((0 + 2 * 5) + 5) && ((frame_get_type_of_local(fp, result))->tag) < ((0 + 2 * 5) + 5) + 4) || (((void)(zero_())), ((frame_get_type_of_local(fp, result))->tag) >= (0 + 2 * 5) && ((frame_get_type_of_local(fp, result))->tag) < (0 + 2 * 5) + 5) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 0)) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 3) || ((frame_get_type_of_local(fp, result))->tag) == ((((0 + 2 * 5) + 5) + 4) + 4)))), 1))) {
    memcpy_fast((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(result) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), flat, t_elem->size);
    goto array_load_end_2;
    } else {
    ptr = u_flat_to_data(t_elem, flat);
    }
  }
 }

array_load_set_ptr_2:
 frame_set_pointer(fp, result, ptr);

array_load_end_2:
 (ip += (1 + ((4) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_LEN2: do {

 frame_t slot_a, slot_r;
 unsigned flags;
 void *ex;

 slot_a = get_unaligned_32(&(ip + 1)[(0) * 2]);
 slot_r = get_unaligned_32(&(ip + 1)[(1) * 2]);
 flags = get_unaligned_32(&(ip + 1)[(2) * 2]);

 ex = u_ipret_array_len(fp, ip, slot_r, slot_a, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + ((3) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_LEN_GREATER_THAN2: do {

 frame_t slot_a, slot_l, slot_r;
 unsigned flags;
 void *ex;

 slot_a = get_unaligned_32(&(ip + 1)[(0) * 2]);
 slot_l = get_unaligned_32(&(ip + 1)[(1) * 2]);
 slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]);
 flags = get_unaligned_32(&(ip + 1)[(3) * 2]);

 ex = u_ipret_array_len_greater_than(fp, ip, slot_r, slot_a, slot_l, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + ((4) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_SUB2: do {

 frame_t slot_a, slot_start, slot_end, slot_r;
 unsigned flags;
 void *ex;

 slot_a = get_unaligned_32(&(ip + 1)[(0) * 2]);
 slot_start = get_unaligned_32(&(ip + 1)[(1) * 2]);
 slot_end = get_unaligned_32(&(ip + 1)[(2) * 2]);
 slot_r = get_unaligned_32(&(ip + 1)[(3) * 2]);
 flags = get_unaligned_32(&(ip + 1)[(4) * 2]);

 ex = u_ipret_array_sub(fp, ip, slot_r, slot_a, slot_start, slot_end, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + ((5) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_SKIP2: do {

 frame_t slot_a, slot_start, slot_r;
 unsigned flags;
 void *ex;

 slot_a = get_unaligned_32(&(ip + 1)[(0) * 2]);
 slot_start = get_unaligned_32(&(ip + 1)[(1) * 2]);
 slot_r = get_unaligned_32(&(ip + 1)[(2) * 2]);
 flags = get_unaligned_32(&(ip + 1)[(3) * 2]);

 ex = u_ipret_array_skip(fp, ip, slot_r, slot_a, slot_start, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + ((4) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_APPEND2: do {

 frame_t slot_r, slot_1, slot_2;
 unsigned flags;
 void *ex;

 slot_r = get_unaligned_32(&(ip + 1)[(0) * 2]);
 flags = get_unaligned_32(&(ip + 1)[(1) * 2]);
 slot_1 = get_unaligned_32(&(ip + 1)[(2) * 2]);
 slot_2 = get_unaligned_32(&(ip + 1)[(3) * 2]);

 ex = u_ipret_array_append(fp, ip, slot_r, slot_1, slot_2, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + ((4) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_APPEND_ONE_FLAT2: do {

 frame_t slot_r, slot_1, slot_2;
 unsigned flags;
 void *ex;

 slot_r = get_unaligned_32(&(ip + 1)[(0) * 2]);
 flags = get_unaligned_32(&(ip + 1)[(1) * 2]);
 slot_1 = get_unaligned_32(&(ip + 1)[(2) * 2]);
 slot_2 = get_unaligned_32(&(ip + 1)[(3) * 2]);

 ex = u_ipret_array_append_one_flat(fp, ip, slot_r, slot_1, slot_2, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + ((4) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_APPEND_ONE2: do {

 frame_t slot_r, slot_1, slot_2;
 unsigned flags;
 void *ex;

 slot_r = get_unaligned_32(&(ip + 1)[(0) * 2]);
 flags = get_unaligned_32(&(ip + 1)[(1) * 2]);
 slot_1 = get_unaligned_32(&(ip + 1)[(2) * 2]);
 slot_2 = get_unaligned_32(&(ip + 1)[(3) * 2]);

 ex = u_ipret_array_append_one(fp, ip, slot_r, slot_1, slot_2, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + ((4) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;

label_OPCODE_ARRAY_FLATTEN2: do {

 frame_t slot_r, slot_1;
 unsigned flags;
 void *ex;

 slot_r = get_unaligned_32(&(ip + 1)[(0) * 2]);
 flags = get_unaligned_32(&(ip + 1)[(1) * 2]);
 slot_1 = get_unaligned_32(&(ip + 1)[(2) * 2]);

 ex = u_ipret_array_flatten(fp, ip, slot_r, slot_1, flags);
 if ((__builtin_expect((int)(ex != ((void *)(uintptr_t)3)), 0)))
  do { if ((ex) != ((void*)0)) { ((void)(zero_())); fp = ((struct execution_control *)(void *)((ex)))->current_frame; ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ((struct execution_control *)(void *)((ex)))->current_ip; (*(&ts) = __c11_atomic_load(&(u_cg_upcall_vector.ts), 0)); goto next_code; } else { goto exit_ipret; } } while (0);

 (ip += (1 + ((3) * 2)));

} while (0); code = *ip; next_label = dispatch[code & 0xffff]; do { } while (0); goto *(void *)next_label;;
# 62 "./ipret.inc" 2
# 694 "ipret.c" 2
# 767 "ipret.c"
exit_ipret:;
}




static void cg_upcall_mem_copy(void *dest, const void *src, size_t size)
{
 memcpy(dest, src, size);
}

static void cg_upcall_mem_clear(void *ptr, size_t len)
{
 memset(ptr, 0, len);
}

static void cg_upcall_pointer_dereference(pointer_t ptr)
{
 u_pointer_dereference_(ptr , "ipret.c" ":" "785");
}

static void cg_upcall_pointer_reference_owned(pointer_t ptr)
{
 pointer_reference_owned(ptr);
}

static pointer_t cg_upcall_flat_to_data(frame_s *fp, uintptr_t slot, const unsigned char *flat)
{
 const struct type *type = frame_get_type_of_local(fp, slot);
 return u_flat_to_data(type, flat);
}

static unsigned char *cg_upcall_data_alloc_function_reference_mayfail(uintptr_t n_curried_arguments)
{
 ajla_error_t sink;
 return ((unsigned char *)(void *)(u_data_alloc_function_reference_mayfail(n_curried_arguments, &sink , "ipret.c" ":" "802")));
}

static unsigned char *cg_upcall_data_alloc_record_mayfail(frame_s *fp, uintptr_t slot)
{
 ajla_error_t sink;
 const struct type *type = frame_get_type_of_local(fp, slot);
 return ((unsigned char *)(void *)(u_data_alloc_record_mayfail((((__builtin_expect((int)((type)->tag == ((((0 + 2 * 5) + 5) + 4) + 2)), 1)) ? (void)0 : internal ("ipret.c" ":" "809", "type_def: invalid type tag %u, expected %u", (type)->tag, ((((0 + 2 * 5) + 5) + 4) + 2))), ((void)sizeof(&(((struct record_definition *)(void *)((((char *)(void *)((type))) - __builtin_offsetof(struct record_definition, type)))))->type == (type)), (((struct record_definition *)(void *)((((char *)(void *)((type))) - __builtin_offsetof(struct record_definition, type))))))), &sink , "ipret.c" ":" "809")));
}

static unsigned char *cg_upcall_data_alloc_option_mayfail(void)
{
 ajla_error_t sink;
 return ((unsigned char *)(void *)(data_init_(((struct data *)(void *)(ptrcomp_verify(((void *)(void *)(mem_align_position((__builtin_offsetof(struct data, u_.option) + sizeof(((struct data *)((void*)0))->u_.option)), (((((uintptr_t)1 << 0) * 2)) >= (1) ? ((((uintptr_t)1 << 0) * 2)) : (1)), &sink , "ipret.c" ":" "815")))))), 4)));
}

static unsigned char *cg_upcall_data_alloc_array_flat_tag_mayfail(uintptr_t tag, int64_t n_entries)
{
 ajla_error_t sink;
 const struct type *type = type_get_from_tag(tag);
 return ((unsigned char *)(void *)(u_data_alloc_array_flat_mayfail(type, n_entries, n_entries, 0, &sink , "ipret.c" ":" "822")));
}

static unsigned char *cg_upcall_data_alloc_array_flat_slot_mayfail(frame_s *fp, uintptr_t slot, int64_t n_entries)
{
 ajla_error_t sink;
 const struct type *type = frame_get_type_of_local(fp, slot);
 return ((unsigned char *)(void *)(u_data_alloc_array_flat_mayfail(type, n_entries, n_entries, 0, &sink , "ipret.c" ":" "829")));
}

static unsigned char *cg_upcall_data_alloc_array_flat_types_ptr_mayfail(frame_s *fp, uintptr_t local_type, int64_t n_entries)
{
 ajla_error_t sink;
 const struct type *type = da_type((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function, local_type);
 return ((unsigned char *)(void *)(u_data_alloc_array_flat_mayfail(type, n_entries, n_entries, 0, &sink , "ipret.c" ":" "836")));
}

static unsigned char *cg_upcall_data_alloc_array_pointers_mayfail(int64_t n_allocated, int64_t n_used)
{
 ajla_error_t sink;
 return ((unsigned char *)(void *)(u_data_alloc_array_pointers_mayfail(n_allocated, n_used, &sink , "ipret.c" ":" "842")));
}

static pointer_t cg_upcall_array_create_flat(frame_s *fp, int64_t length, uintptr_t content_slot)
{
 array_index_t idx;
 const struct type *content_type = frame_get_type_of_local(fp, content_slot);
 index_from_int_(&idx, length , "ipret.c" ":" "849");
 return u_array_create(idx, content_type, (((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(content_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))), pointer_empty());
}

static pointer_t cg_upcall_array_create_pointers(frame_s *fp, uintptr_t ip_offset, uintptr_t length_slot, pointer_t ptr)
{
 array_index_t idx;
 int64_t length = *(((int64_t *)(void *)((((void)(zero_())), ((void)(zero_())), ((((unsigned char *)(void *)(((((unsigned char *)(void *)(fp))) + ((size_t)(length_slot) << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5))))))))))));
 if ((__builtin_expect((int)(length < 0), 0))) {
  code_t *ip;
  u_pointer_dereference_(ptr , "ipret.c" ":" "859");
  ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ip_offset;
  return u_pointer_error(error_ajla_aux_(1, 8, 0 , "ipret.c" ":" "861"), fp, ip , "ipret.c" ":" "861");
 }
 index_from_int_(&idx, length , "ipret.c" ":" "863");
 return u_array_create(idx, ((void*)0), ((void*)0), ptr);
}

static pointer_t cg_upcall_array_create_sparse(int64_t length, pointer_t ptr)
{
 array_index_t idx;
 index_from_int_(&idx, length , "ipret.c" ":" "870");
 return u_array_create_sparse(idx, ptr);
}

static pointer_t cg_upcall_array_sub(pointer_t array, int64_t start, int64_t end, _Bool deref)
{
 pointer_t res_ptr;
 ajla_error_t err;
 struct data *d, *s;
 array_index_t idx_start, idx_end, idx_len, idx_array_len;
 if ((__builtin_expect((int)((start | end) < 0), 0)))
  goto fail1;
 if ((__builtin_expect((int)(start > end), 0)))
  goto fail1;
 if ((__builtin_expect((int)(pointer_is_thunk(array)), 0)))
  goto fail1;
 index_from_int_(&idx_start, start , "ipret.c" ":" "886");
 index_from_int_(&idx_end, end , "ipret.c" ":" "887");
 index_from_int_(&idx_len, end - start , "ipret.c" ":" "888");
 d = pointer_get_data_(array , "ipret.c" ":" "889");
 if ((__builtin_expect((int)((((void)(zero_())), (refcount_tag_get((const refcount_t *)&(d)->refcount_))) == 10), 0)))
  goto fail2;
 idx_array_len = u_array_len(d);
 if ((__builtin_expect((int)(!index_ge_index_(idx_array_len, idx_end , "ipret.c" ":" "893")), 0))) {
  index_free_(&idx_array_len , "ipret.c" ":" "894");
  goto fail2;
 }
 index_free_(&idx_array_len , "ipret.c" ":" "897");
 index_free_(&idx_end , "ipret.c" ":" "898");
 s = u_array_sub(d, idx_start, idx_len, deref, &err);
 if ((__builtin_expect((int)(!s), 0))) {
  res_ptr = u_pointer_error(err, ((void*)0), 0 , "ipret.c" ":" "901");
 } else {
  res_ptr = pointer_data(s);
 }
 return res_ptr;
fail2:
 index_free_(&idx_start , "ipret.c" ":" "907");
 index_free_(&idx_end , "ipret.c" ":" "908");
 index_free_(&idx_len , "ipret.c" ":" "909");
fail1:
 return pointer_empty();
}

static pointer_t cg_upcall_array_skip(pointer_t array, int64_t start, _Bool deref)
{
 pointer_t res_ptr;
 ajla_error_t err;
 struct data *d, *s;
 array_index_t idx_start, idx_array_len;
 if ((__builtin_expect((int)(start < 0), 0)))
  goto fail1;
 if ((__builtin_expect((int)(pointer_is_thunk(array)), 0)))
  goto fail1;
 d = pointer_get_data_(array , "ipret.c" ":" "924");
 if ((__builtin_expect((int)((((void)(zero_())), (refcount_tag_get((const refcount_t *)&(d)->refcount_))) == 10), 0)))
  goto fail1;
 index_from_int_(&idx_start, start , "ipret.c" ":" "927");
 idx_array_len = u_array_len(d);
 if ((__builtin_expect((int)(!index_ge_index_(idx_array_len, idx_start , "ipret.c" ":" "929")), 0))) {
  goto fail2;
 }
 index_sub_int_(&idx_array_len, start , "ipret.c" ":" "932");
 s = u_array_sub(d, idx_start, idx_array_len, deref, &err);
 if ((__builtin_expect((int)(!s), 0))) {
  res_ptr = u_pointer_error(err, ((void*)0), 0 , "ipret.c" ":" "935");
 } else {
  res_ptr = pointer_data(s);
 }
 return res_ptr;
fail2:
 index_free_(&idx_array_len , "ipret.c" ":" "941");
 index_free_(&idx_start , "ipret.c" ":" "942");
fail1:
 return pointer_empty();
}

static pointer_t cg_upcall_array_join(pointer_t ptr1, pointer_t ptr2)
{
 ajla_error_t err;
 struct data *d1 = pointer_get_data_(ptr1 , "ipret.c" ":" "950");
 struct data *d2 = pointer_get_data_(ptr2 , "ipret.c" ":" "951");
 struct data *d = u_array_join(d1, d2, &err);
 if ((__builtin_expect((int)(!d), 0)))
  return u_pointer_error(err, ((void*)0), ((void*)0) , "ipret.c" ":" "954");
 return pointer_data(d);
}

static void *cg_upcall_ipret_io(frame_s *fp, uintptr_t ip_offset, uintptr_t code_params)
{
 void *ret;
 code_t *ip = ((((void)(zero_()))), &((((struct frame_struct *)(void *)(((const char *)(void *)(fp)) - (((__builtin_offsetof(struct frame_struct, variables_)) + (((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1) & ~((((size_t)1 << ( sizeof(pointer_t) <= 2 ? 1 : sizeof(pointer_t) <= 4 ? 2 : sizeof(pointer_t) <= 8 ? 3 : sizeof(pointer_t) <= 16 ? 4 : (5)))) - 1 + 0 * (__builtin_offsetof(struct frame_struct, variables_)))))))->function)->u_.function)->code + ip_offset;
 unsigned char io_code = code_params >> 24;
 unsigned char n_outputs = code_params >> 16;
 unsigned char n_inputs = code_params >> 8;
 unsigned char n_params = code_params;

 ret = u_ipret_io(fp, ip, io_code, n_outputs, n_inputs, n_params);

 return ret;
}

static pointer_t cg_upcall_ipret_copy_variable_to_pointer(frame_s *src_fp, uintptr_t src_slot, _Bool deref)
{
 return u_ipret_copy_variable_to_pointer(src_fp, src_slot, deref);
}

static int64_t cg_upcall_ipret_system_property(int64_t idx)
{
 return u_ipret_system_property(idx);
}
# 1002 "ipret.c"
 static _Bool FIXED_uto_int_int8_t(const uint8_t *v1, int64_t *r) { int64_t ret; ret = (int64_t)*v1; if ((__builtin_expect((int)((uint8_t)ret != *v1), 0)) || (__builtin_expect((int)(ret < 0), 0))) return 0; *r = ret; return 1; } static _Bool FIXED_ufrom_int_int8_t(const int64_t *v1, uint8_t *r) { uint8_t ret; ret = (uint8_t)*v1; if ((__builtin_expect((int)((int64_t)ret != *v1), 0)) || (__builtin_expect((int)(*v1 < 0), 0))) return 0; *r = ret; return 1; } static _Bool FIXED_uto_int_int16_t(const uint16_t *v1, int64_t *r) { int64_t ret; ret = (int64_t)*v1; if ((__builtin_expect((int)((uint16_t)ret != *v1), 0)) || (__builtin_expect((int)(ret < 0), 0))) return 0; *r = ret; return 1; } static _Bool FIXED_ufrom_int_int16_t(const int64_t *v1, uint16_t *r) { uint16_t ret; ret = (uint16_t)*v1; if ((__builtin_expect((int)((int64_t)ret != *v1), 0)) || (__builtin_expect((int)(*v1 < 0), 0))) return 0; *r = ret; return 1; } static _Bool FIXED_uto_int_int32_t(const uint32_t *v1, int64_t *r) { int64_t ret; ret = (int64_t)*v1; if ((__builtin_expect((int)((uint32_t)ret != *v1), 0)) || (__builtin_expect((int)(ret < 0), 0))) return 0; *r = ret; return 1; } static _Bool FIXED_ufrom_int_int32_t(const int64_t *v1, uint32_t *r) { uint32_t ret; ret = (uint32_t)*v1; if ((__builtin_expect((int)((int64_t)ret != *v1), 0)) || (__builtin_expect((int)(*v1 < 0), 0))) return 0; *r = ret; return 1; } static _Bool FIXED_uto_int_int64_t(const uint64_t *v1, int64_t *r) { int64_t ret; ret = (int64_t)*v1; if ((__builtin_expect((int)((uint64_t)ret != *v1), 0)) || (__builtin_expect((int)(ret < 0), 0))) return 0; *r = ret; return 1; } static _Bool FIXED_ufrom_int_int64_t(const int64_t *v1, uint64_t *r) { uint64_t ret; ret = (uint64_t)*v1; if ((__builtin_expect((int)((int64_t)ret != *v1), 0)) || (__builtin_expect((int)(*v1 < 0), 0))) return 0; *r = ret; return 1; } static _Bool FIXED_uto_int_int128_t(const uint128_t *v1, int64_t *r) { int64_t ret; ret = (int64_t)*v1; if ((__builtin_expect((int)((uint128_t)ret != *v1), 0)) || (__builtin_expect((int)(ret < 0), 0))) return 0; *r = ret; return 1; } static _Bool FIXED_ufrom_int_int128_t(const int64_t *v1, uint128_t *r) { uint128_t ret; ret = (uint128_t)*v1; if ((__builtin_expect((int)((int64_t)ret != *v1), 0)) || (__builtin_expect((int)(*v1 < 0), 0))) return 0; *r = ret; return 1; }
# 1016 "ipret.c"
struct cg_upcall_vector_s u_cg_upcall_vector = {
 0,

 cg_upcall_mem_copy,
 cg_upcall_mem_clear,
 cg_upcall_pointer_dereference,
 cg_upcall_pointer_reference_owned,
 cg_upcall_flat_to_data,
 cg_upcall_data_alloc_function_reference_mayfail,
 cg_upcall_data_alloc_record_mayfail,
 cg_upcall_data_alloc_option_mayfail,
 cg_upcall_data_alloc_array_flat_tag_mayfail,
 cg_upcall_data_alloc_array_flat_slot_mayfail,
 cg_upcall_data_alloc_array_flat_types_ptr_mayfail,
 cg_upcall_data_alloc_array_pointers_mayfail,
 cg_upcall_array_create_flat,
 cg_upcall_array_create_pointers,
 cg_upcall_array_create_sparse,
 cg_upcall_array_sub,
 cg_upcall_array_skip,
 cg_upcall_array_join,
 cg_upcall_ipret_io,
 cg_upcall_ipret_copy_variable_to_pointer,
 cg_upcall_ipret_system_property,
 FIXED_binary_add_int128_t,
 FIXED_binary_subtract_int128_t,


 FIXED_binary_multiply_int8_t, FIXED_binary_multiply_int16_t, FIXED_binary_multiply_int32_t, FIXED_binary_multiply_int64_t, FIXED_binary_multiply_int128_t,



 FIXED_binary_divide_int8_t, FIXED_binary_divide_int16_t, FIXED_binary_divide_int32_t, FIXED_binary_divide_int64_t, FIXED_binary_divide_int128_t,



 FIXED_binary_udivide_int8_t, FIXED_binary_udivide_int16_t, FIXED_binary_udivide_int32_t, FIXED_binary_udivide_int64_t, FIXED_binary_udivide_int128_t,



 FIXED_binary_modulo_int8_t, FIXED_binary_modulo_int16_t, FIXED_binary_modulo_int32_t, FIXED_binary_modulo_int64_t, FIXED_binary_modulo_int128_t,



 FIXED_binary_umodulo_int8_t, FIXED_binary_umodulo_int16_t, FIXED_binary_umodulo_int32_t, FIXED_binary_umodulo_int64_t, FIXED_binary_umodulo_int128_t,



 FIXED_binary_power_int8_t, FIXED_binary_power_int16_t, FIXED_binary_power_int32_t, FIXED_binary_power_int64_t, FIXED_binary_power_int128_t,

 FIXED_binary_shl_int128_t,
 FIXED_binary_shr_int128_t,
 FIXED_binary_ushr_int128_t,
 FIXED_binary_rol_int128_t,
 FIXED_binary_ror_int128_t,
 FIXED_binary_bts_int128_t,
 FIXED_binary_btr_int128_t,
 FIXED_binary_btc_int128_t,
 FIXED_binary_less_int128_t,
 FIXED_binary_less_equal_int128_t,
 FIXED_binary_uless_int128_t,
 FIXED_binary_uless_equal_int128_t,
 FIXED_binary_bt_int128_t,
 FIXED_unary_neg_int128_t,
 FIXED_unary_inc_int128_t,
 FIXED_unary_dec_int128_t,


 FIXED_unary_bswap_int8_t, FIXED_unary_bswap_int16_t, FIXED_unary_bswap_int32_t, FIXED_unary_bswap_int64_t, FIXED_unary_bswap_int128_t,



 FIXED_unary_brev_int8_t, FIXED_unary_brev_int16_t, FIXED_unary_brev_int32_t, FIXED_unary_brev_int64_t, FIXED_unary_brev_int128_t,



 FIXED_unary_bsf_int8_t, FIXED_unary_bsf_int16_t, FIXED_unary_bsf_int32_t, FIXED_unary_bsf_int64_t, FIXED_unary_bsf_int128_t,



 FIXED_unary_bsr_int8_t, FIXED_unary_bsr_int16_t, FIXED_unary_bsr_int32_t, FIXED_unary_bsr_int64_t, FIXED_unary_bsr_int128_t,



 FIXED_unary_popcnt_int8_t, FIXED_unary_popcnt_int16_t, FIXED_unary_popcnt_int32_t, FIXED_unary_popcnt_int64_t, FIXED_unary_popcnt_int128_t,



 FIXED_uto_int_int8_t, FIXED_uto_int_int16_t, FIXED_uto_int_int32_t, FIXED_uto_int_int64_t, FIXED_uto_int_int128_t,



 FIXED_ufrom_int_int8_t, FIXED_ufrom_int_int16_t, FIXED_ufrom_int_int32_t, FIXED_ufrom_int_int64_t, FIXED_ufrom_int_int128_t,

 INT_binary_add_int128_t,
 INT_binary_subtract_int128_t,


 INT_binary_multiply_int8_t, INT_binary_multiply_int16_t, INT_binary_multiply_int32_t, INT_binary_multiply_int64_t, INT_binary_multiply_int128_t,



 INT_binary_divide_int8_t, INT_binary_divide_int16_t, INT_binary_divide_int32_t, INT_binary_divide_int64_t, INT_binary_divide_int128_t,



 INT_binary_modulo_int8_t, INT_binary_modulo_int16_t, INT_binary_modulo_int32_t, INT_binary_modulo_int64_t, INT_binary_modulo_int128_t,



 INT_binary_power_int8_t, INT_binary_power_int16_t, INT_binary_power_int32_t, INT_binary_power_int64_t, INT_binary_power_int128_t,

 INT_binary_shl_int128_t,
 INT_binary_shr_int128_t,
 INT_binary_bts_int128_t,
 INT_binary_btr_int128_t,
 INT_binary_btc_int128_t,
 INT_binary_bt_int128_t,
 INT_unary_neg_int128_t,
 INT_unary_inc_int128_t,
 INT_unary_dec_int128_t,


 INT_unary_bsf_int8_t, INT_unary_bsf_int16_t, INT_unary_bsf_int32_t, INT_unary_bsf_int64_t, INT_unary_bsf_int128_t,



 INT_unary_bsr_int8_t, INT_unary_bsr_int16_t, INT_unary_bsr_int32_t, INT_unary_bsr_int64_t, INT_unary_bsr_int128_t,



 INT_unary_popcnt_int8_t, INT_unary_popcnt_int16_t, INT_unary_popcnt_int32_t, INT_unary_popcnt_int64_t, INT_unary_popcnt_int128_t,



 REAL_binary_add_real16_t, REAL_binary_add_real32_t, REAL_binary_add_real64_t, REAL_binary_add_real80_t,



 REAL_binary_subtract_real16_t, REAL_binary_subtract_real32_t, REAL_binary_subtract_real64_t, REAL_binary_subtract_real80_t,



 REAL_binary_multiply_real16_t, REAL_binary_multiply_real32_t, REAL_binary_multiply_real64_t, REAL_binary_multiply_real80_t,



 REAL_binary_divide_real16_t, REAL_binary_divide_real32_t, REAL_binary_divide_real64_t, REAL_binary_divide_real80_t,



 REAL_binary_modulo_real16_t, REAL_binary_modulo_real32_t, REAL_binary_modulo_real64_t, REAL_binary_modulo_real80_t,



 REAL_binary_power_real16_t, REAL_binary_power_real32_t, REAL_binary_power_real64_t, REAL_binary_power_real80_t,



 REAL_binary_ldexp_real16_t, REAL_binary_ldexp_real32_t, REAL_binary_ldexp_real64_t, REAL_binary_ldexp_real80_t,



 REAL_binary_atan2_real16_t, REAL_binary_atan2_real32_t, REAL_binary_atan2_real64_t, REAL_binary_atan2_real80_t,



 REAL_binary_equal_real16_t, REAL_binary_equal_real32_t, REAL_binary_equal_real64_t, REAL_binary_equal_real80_t,



 REAL_binary_not_equal_real16_t, REAL_binary_not_equal_real32_t, REAL_binary_not_equal_real64_t, REAL_binary_not_equal_real80_t,



 REAL_binary_less_real16_t, REAL_binary_less_real32_t, REAL_binary_less_real64_t, REAL_binary_less_real80_t,



 REAL_binary_less_equal_real16_t, REAL_binary_less_equal_real32_t, REAL_binary_less_equal_real64_t, REAL_binary_less_equal_real80_t,



 REAL_unary_neg_real16_t, REAL_unary_neg_real32_t, REAL_unary_neg_real64_t, REAL_unary_neg_real80_t,



 REAL_unary_sqrt_real16_t, REAL_unary_sqrt_real32_t, REAL_unary_sqrt_real64_t, REAL_unary_sqrt_real80_t,



 REAL_unary_cbrt_real16_t, REAL_unary_cbrt_real32_t, REAL_unary_cbrt_real64_t, REAL_unary_cbrt_real80_t,



 REAL_unary_sin_real16_t, REAL_unary_sin_real32_t, REAL_unary_sin_real64_t, REAL_unary_sin_real80_t,



 REAL_unary_cos_real16_t, REAL_unary_cos_real32_t, REAL_unary_cos_real64_t, REAL_unary_cos_real80_t,



 REAL_unary_tan_real16_t, REAL_unary_tan_real32_t, REAL_unary_tan_real64_t, REAL_unary_tan_real80_t,



 REAL_unary_asin_real16_t, REAL_unary_asin_real32_t, REAL_unary_asin_real64_t, REAL_unary_asin_real80_t,



 REAL_unary_acos_real16_t, REAL_unary_acos_real32_t, REAL_unary_acos_real64_t, REAL_unary_acos_real80_t,



 REAL_unary_atan_real16_t, REAL_unary_atan_real32_t, REAL_unary_atan_real64_t, REAL_unary_atan_real80_t,



 REAL_unary_sinh_real16_t, REAL_unary_sinh_real32_t, REAL_unary_sinh_real64_t, REAL_unary_sinh_real80_t,



 REAL_unary_cosh_real16_t, REAL_unary_cosh_real32_t, REAL_unary_cosh_real64_t, REAL_unary_cosh_real80_t,



 REAL_unary_tanh_real16_t, REAL_unary_tanh_real32_t, REAL_unary_tanh_real64_t, REAL_unary_tanh_real80_t,



 REAL_unary_asinh_real16_t, REAL_unary_asinh_real32_t, REAL_unary_asinh_real64_t, REAL_unary_asinh_real80_t,



 REAL_unary_acosh_real16_t, REAL_unary_acosh_real32_t, REAL_unary_acosh_real64_t, REAL_unary_acosh_real80_t,



 REAL_unary_atanh_real16_t, REAL_unary_atanh_real32_t, REAL_unary_atanh_real64_t, REAL_unary_atanh_real80_t,



 REAL_unary_exp2_real16_t, REAL_unary_exp2_real32_t, REAL_unary_exp2_real64_t, REAL_unary_exp2_real80_t,



 REAL_unary_exp_real16_t, REAL_unary_exp_real32_t, REAL_unary_exp_real64_t, REAL_unary_exp_real80_t,



 REAL_unary_exp10_real16_t, REAL_unary_exp10_real32_t, REAL_unary_exp10_real64_t, REAL_unary_exp10_real80_t,



 REAL_unary_log2_real16_t, REAL_unary_log2_real32_t, REAL_unary_log2_real64_t, REAL_unary_log2_real80_t,



 REAL_unary_log_real16_t, REAL_unary_log_real32_t, REAL_unary_log_real64_t, REAL_unary_log_real80_t,



 REAL_unary_log10_real16_t, REAL_unary_log10_real32_t, REAL_unary_log10_real64_t, REAL_unary_log10_real80_t,



 REAL_unary_round_real16_t, REAL_unary_round_real32_t, REAL_unary_round_real64_t, REAL_unary_round_real80_t,



 REAL_unary_ceil_real16_t, REAL_unary_ceil_real32_t, REAL_unary_ceil_real64_t, REAL_unary_ceil_real80_t,



 REAL_unary_floor_real16_t, REAL_unary_floor_real32_t, REAL_unary_floor_real64_t, REAL_unary_floor_real80_t,



 REAL_unary_trunc_real16_t, REAL_unary_trunc_real32_t, REAL_unary_trunc_real64_t, REAL_unary_trunc_real80_t,



 REAL_unary_fract_real16_t, REAL_unary_fract_real32_t, REAL_unary_fract_real64_t, REAL_unary_fract_real80_t,



 REAL_unary_mantissa_real16_t, REAL_unary_mantissa_real32_t, REAL_unary_mantissa_real64_t, REAL_unary_mantissa_real80_t,



 REAL_unary_exponent_real16_t, REAL_unary_exponent_real32_t, REAL_unary_exponent_real64_t, REAL_unary_exponent_real80_t,



 REAL_unary_next_number_real16_t, REAL_unary_next_number_real32_t, REAL_unary_next_number_real64_t, REAL_unary_next_number_real80_t,



 REAL_unary_prev_number_real16_t, REAL_unary_prev_number_real32_t, REAL_unary_prev_number_real64_t, REAL_unary_prev_number_real80_t,



 REAL_unary_to_int_real16_t, REAL_unary_to_int_real32_t, REAL_unary_to_int_real64_t, REAL_unary_to_int_real80_t,



 REAL_unary_from_int_real16_t, REAL_unary_from_int_real32_t, REAL_unary_from_int_real64_t, REAL_unary_from_int_real80_t,



 REAL_unary_is_exception_real16_t, REAL_unary_is_exception_real32_t, REAL_unary_is_exception_real64_t, REAL_unary_is_exception_real80_t,





};

void u_ipret_init(void)
{
# 1347 "ipret.c"
 tick_stamp_ptr = &(u_cg_upcall_vector.ts);
}

void u_ipret_done(void)
{
}