Attachment 934734 Details for Bug 1106758 – preprocessed file

preprocessed file

cpu.i (text/plain), 1.36 MB, created by Dan Horák on 2014-09-05 10:40:34 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Dan Horák

Created: 2014-09-05 10:40:34 UTC

Size: 1.36 MB

patch

obsolete

># 1 "cpu.c"
># 1 "/home/dan/hercules/hercules-3.10//"
># 1 "<built-in>"
># 1 "<command-line>"
># 1 "/usr/include/stdc-predef.h" 1 3 4
># 1 "<command-line>" 2
># 1 "cpu.c"
># 30 "cpu.c"
># 1 "hstdinc.h" 1
># 12 "hstdinc.h"
># 1 "./config.h" 1
># 13 "hstdinc.h" 2
># 51 "hstdinc.h"
># 1 "/usr/include/stdio.h" 1 3 4
># 27 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/features.h" 1 3 4
># 365 "/usr/include/features.h" 3 4
># 1 "/usr/include/sys/cdefs.h" 1 3 4
># 393 "/usr/include/sys/cdefs.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 394 "/usr/include/sys/cdefs.h" 2 3 4
># 366 "/usr/include/features.h" 2 3 4
># 389 "/usr/include/features.h" 3 4
># 1 "/usr/include/gnu/stubs.h" 1 3 4
>
>
>
>
>
>
># 1 "/usr/include/gnu/stubs-32.h" 1 3 4
># 8 "/usr/include/gnu/stubs.h" 2 3 4
># 390 "/usr/include/features.h" 2 3 4
># 28 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 212 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stddef.h" 3 4
>typedef unsigned int size_t;
># 34 "/usr/include/stdio.h" 2 3 4
>
># 1 "/usr/include/bits/types.h" 1 3 4
># 27 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 28 "/usr/include/bits/types.h" 2 3 4
>
>
>typedef unsigned char __u_char;
>typedef unsigned short int __u_short;
>typedef unsigned int __u_int;
>typedef unsigned long int __u_long;
>
>
>typedef signed char __int8_t;
>typedef unsigned char __uint8_t;
>typedef signed short int __int16_t;
>typedef unsigned short int __uint16_t;
>typedef signed int __int32_t;
>typedef unsigned int __uint32_t;
>
>
>
>
>__extension__ typedef signed long long int __int64_t;
>__extension__ typedef unsigned long long int __uint64_t;
>
>
>
>
>
>
>
>__extension__ typedef long long int __quad_t;
>__extension__ typedef unsigned long long int __u_quad_t;
># 121 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/typesizes.h" 1 3 4
># 122 "/usr/include/bits/types.h" 2 3 4
>
>
>__extension__ typedef __u_quad_t __dev_t;
>__extension__ typedef unsigned int __uid_t;
>__extension__ typedef unsigned int __gid_t;
>__extension__ typedef unsigned long int __ino_t;
>__extension__ typedef __u_quad_t __ino64_t;
>__extension__ typedef unsigned int __mode_t;
>__extension__ typedef unsigned int __nlink_t;
>__extension__ typedef long int __off_t;
>__extension__ typedef __quad_t __off64_t;
>__extension__ typedef int __pid_t;
>__extension__ typedef struct { int __val[2]; } __fsid_t;
>__extension__ typedef long int __clock_t;
>__extension__ typedef unsigned long int __rlim_t;
>__extension__ typedef __u_quad_t __rlim64_t;
>__extension__ typedef unsigned int __id_t;
>__extension__ typedef long int __time_t;
>__extension__ typedef unsigned int __useconds_t;
>__extension__ typedef long int __suseconds_t;
>
>__extension__ typedef int __daddr_t;
>__extension__ typedef int __key_t;
>
>
>__extension__ typedef int __clockid_t;
>
>
>__extension__ typedef void * __timer_t;
>
>
>__extension__ typedef long int __blksize_t;
>
>
>
>
>__extension__ typedef long int __blkcnt_t;
>__extension__ typedef __quad_t __blkcnt64_t;
>
>
>__extension__ typedef unsigned long int __fsblkcnt_t;
>__extension__ typedef __u_quad_t __fsblkcnt64_t;
>
>
>__extension__ typedef unsigned long int __fsfilcnt_t;
>__extension__ typedef __u_quad_t __fsfilcnt64_t;
>
>
>__extension__ typedef int __fsword_t;
>
>__extension__ typedef int __ssize_t;
>
>
>__extension__ typedef long int __syscall_slong_t;
>
>__extension__ typedef unsigned long int __syscall_ulong_t;
>
>
>
>typedef __off64_t __loff_t;
>typedef __quad_t *__qaddr_t;
>typedef char *__caddr_t;
>
>
>__extension__ typedef int __intptr_t;
>
>
>__extension__ typedef unsigned int __socklen_t;
># 36 "/usr/include/stdio.h" 2 3 4
># 44 "/usr/include/stdio.h" 3 4
>struct _IO_FILE;
>
>
>
>typedef struct _IO_FILE FILE;
>
>
>
>
>
># 64 "/usr/include/stdio.h" 3 4
>typedef struct _IO_FILE __FILE;
># 74 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/libio.h" 1 3 4
># 31 "/usr/include/libio.h" 3 4
># 1 "/usr/include/_G_config.h" 1 3 4
># 15 "/usr/include/_G_config.h" 3 4
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 16 "/usr/include/_G_config.h" 2 3 4
>
>
>
>
># 1 "/usr/include/wchar.h" 1 3 4
># 82 "/usr/include/wchar.h" 3 4
>typedef struct
>{
>  int __count;
>  union
>  {
>
>    unsigned int __wch;
>
>
>
>    char __wchb[4];
>  } __value;
>} __mbstate_t;
># 21 "/usr/include/_G_config.h" 2 3 4
>typedef struct
>{
>  __off_t __pos;
>  __mbstate_t __state;
>} _G_fpos_t;
>typedef struct
>{
>  __off64_t __pos;
>  __mbstate_t __state;
>} _G_fpos64_t;
># 32 "/usr/include/libio.h" 2 3 4
># 49 "/usr/include/libio.h" 3 4
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stdarg.h" 1 3 4
># 40 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stdarg.h" 3 4
>typedef __builtin_va_list __gnuc_va_list;
># 50 "/usr/include/libio.h" 2 3 4
># 144 "/usr/include/libio.h" 3 4
>struct _IO_jump_t; struct _IO_FILE;
># 154 "/usr/include/libio.h" 3 4
>typedef void _IO_lock_t;
>
>
>
>
>
>struct _IO_marker {
>  struct _IO_marker *_next;
>  struct _IO_FILE *_sbuf;
>
>
>
>  int _pos;
># 177 "/usr/include/libio.h" 3 4
>};
>
>
>enum __codecvt_result
>{
>  __codecvt_ok,
>  __codecvt_partial,
>  __codecvt_error,
>  __codecvt_noconv
>};
># 245 "/usr/include/libio.h" 3 4
>struct _IO_FILE {
>  int _flags;
>
>
>
>
>  char* _IO_read_ptr;
>  char* _IO_read_end;
>  char* _IO_read_base;
>  char* _IO_write_base;
>  char* _IO_write_ptr;
>  char* _IO_write_end;
>  char* _IO_buf_base;
>  char* _IO_buf_end;
>
>  char *_IO_save_base;
>  char *_IO_backup_base;
>  char *_IO_save_end;
>
>  struct _IO_marker *_markers;
>
>  struct _IO_FILE *_chain;
>
>  int _fileno;
>
>
>
>  int _flags2;
>
>  __off_t _old_offset;
>
>
>
>  unsigned short _cur_column;
>  signed char _vtable_offset;
>  char _shortbuf[1];
>
>
>
>  _IO_lock_t *_lock;
># 293 "/usr/include/libio.h" 3 4
>  __off64_t _offset;
># 302 "/usr/include/libio.h" 3 4
>  void *__pad1;
>  void *__pad2;
>  void *__pad3;
>  void *__pad4;
>  size_t __pad5;
>
>  int _mode;
>
>  char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
>
>};
>
>
>typedef struct _IO_FILE _IO_FILE;
>
>
>struct _IO_FILE_plus;
>
>extern struct _IO_FILE_plus _IO_2_1_stdin_;
>extern struct _IO_FILE_plus _IO_2_1_stdout_;
>extern struct _IO_FILE_plus _IO_2_1_stderr_;
># 338 "/usr/include/libio.h" 3 4
>typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
>
>
>
>
>
>
>
>typedef __ssize_t __io_write_fn (void *__cookie, const char *__buf,
>     size_t __n);
>
>
>
>
>
>
>
>typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
>
>
>typedef int __io_close_fn (void *__cookie);
>
>
>
>
>typedef __io_read_fn cookie_read_function_t;
>typedef __io_write_fn cookie_write_function_t;
>typedef __io_seek_fn cookie_seek_function_t;
>typedef __io_close_fn cookie_close_function_t;
>
>
>typedef struct
>{
>  __io_read_fn *read;
>  __io_write_fn *write;
>  __io_seek_fn *seek;
>  __io_close_fn *close;
>} _IO_cookie_io_functions_t;
>typedef _IO_cookie_io_functions_t cookie_io_functions_t;
>
>struct _IO_cookie_file;
>
>
>extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
>        void *__cookie, _IO_cookie_io_functions_t __fns);
>
>
>
>
>
>
>
>extern int __underflow (_IO_FILE *);
>extern int __uflow (_IO_FILE *);
>extern int __overflow (_IO_FILE *, int);
># 434 "/usr/include/libio.h" 3 4
>extern int _IO_getc (_IO_FILE *__fp);
>extern int _IO_putc (int __c, _IO_FILE *__fp);
>extern int _IO_feof (_IO_FILE *__fp) __attribute__ ((__nothrow__ , __leaf__));
>extern int _IO_ferror (_IO_FILE *__fp) __attribute__ ((__nothrow__ , __leaf__));
>
>extern int _IO_peekc_locked (_IO_FILE *__fp);
>
>
>
>
>
>extern void _IO_flockfile (_IO_FILE *) __attribute__ ((__nothrow__ , __leaf__));
>extern void _IO_funlockfile (_IO_FILE *) __attribute__ ((__nothrow__ , __leaf__));
>extern int _IO_ftrylockfile (_IO_FILE *) __attribute__ ((__nothrow__ , __leaf__));
># 464 "/usr/include/libio.h" 3 4
>extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
>   __gnuc_va_list, int *__restrict);
>extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
>    __gnuc_va_list);
>extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
>extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);
>
>extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);
>extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);
>
>extern void _IO_free_backup_area (_IO_FILE *) __attribute__ ((__nothrow__ , __leaf__));
># 75 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>typedef __gnuc_va_list va_list;
># 92 "/usr/include/stdio.h" 3 4
>typedef __off64_t off_t;
>
>
>
>
>typedef __off64_t off64_t;
>
>
>
>
>typedef __ssize_t ssize_t;
>
>
>
>
>
>
>
>
>
>typedef _G_fpos64_t fpos_t;
>
>
>
>typedef _G_fpos64_t fpos64_t;
># 164 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/bits/stdio_lim.h" 1 3 4
># 165 "/usr/include/stdio.h" 2 3 4
>
>
>
>extern struct _IO_FILE *stdin;
>extern struct _IO_FILE *stdout;
>extern struct _IO_FILE *stderr;
>
>
>
>
>
>
>
>extern int remove (const char *__filename) __attribute__ ((__nothrow__ , __leaf__));
>
>extern int rename (const char *__old, const char *__new) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int renameat (int __oldfd, const char *__old, int __newfd,
>       const char *__new) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
># 198 "/usr/include/stdio.h" 3 4
>extern FILE *tmpfile (void) __asm__ ("" "tmpfile64") __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern FILE *tmpfile64 (void) __attribute__ ((__warn_unused_result__));
>
>
>
>extern char *tmpnam (char *__s) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern char *tmpnam_r (char *__s) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
># 227 "/usr/include/stdio.h" 3 4
>extern char *tempnam (const char *__dir, const char *__pfx)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>
>extern int fclose (FILE *__stream);
>
>
>
>
>extern int fflush (FILE *__stream);
>
># 252 "/usr/include/stdio.h" 3 4
>extern int fflush_unlocked (FILE *__stream);
># 262 "/usr/include/stdio.h" 3 4
>extern int fcloseall (void);
>
>
>
>
># 283 "/usr/include/stdio.h" 3 4
>extern FILE *fopen (const char *__restrict __filename, const char *__restrict __modes) __asm__ ("" "fopen64")
>
>  __attribute__ ((__warn_unused_result__));
>extern FILE *freopen (const char *__restrict __filename, const char *__restrict __modes, FILE *__restrict __stream) __asm__ ("" "freopen64")
>
>
>  __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>extern FILE *fopen64 (const char *__restrict __filename,
>        const char *__restrict __modes) __attribute__ ((__warn_unused_result__));
>extern FILE *freopen64 (const char *__restrict __filename,
>   const char *__restrict __modes,
>   FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern FILE *fdopen (int __fd, const char *__modes) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern FILE *fopencookie (void *__restrict __magic_cookie,
>     const char *__restrict __modes,
>     _IO_cookie_io_functions_t __io_funcs) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
>  __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
>      int __modes, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
>         size_t __size) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern void setlinebuf (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern int fprintf (FILE *__restrict __stream,
>      const char *__restrict __format, ...);
>
>
>
>
>extern int printf (const char *__restrict __format, ...);
>
>extern int sprintf (char *__restrict __s,
>      const char *__restrict __format, ...) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
>       __gnuc_va_list __arg);
>
>
>
>
>extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
>
>extern int vsprintf (char *__restrict __s, const char *__restrict __format,
>       __gnuc_va_list __arg) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern int snprintf (char *__restrict __s, size_t __maxlen,
>       const char *__restrict __format, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 4)));
>
>extern int vsnprintf (char *__restrict __s, size_t __maxlen,
>        const char *__restrict __format, __gnuc_va_list __arg)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 0)));
>
>
>
>
>
>
>extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
>        __gnuc_va_list __arg)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 0))) __attribute__ ((__warn_unused_result__));
>extern int __asprintf (char **__restrict __ptr,
>         const char *__restrict __fmt, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 3))) __attribute__ ((__warn_unused_result__));
>extern int asprintf (char **__restrict __ptr,
>       const char *__restrict __fmt, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 3))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int vdprintf (int __fd, const char *__restrict __fmt,
>       __gnuc_va_list __arg)
>     __attribute__ ((__format__ (__printf__, 2, 0)));
>extern int dprintf (int __fd, const char *__restrict __fmt, ...)
>     __attribute__ ((__format__ (__printf__, 2, 3)));
>
>
>
>
>
>
>
>
>extern int fscanf (FILE *__restrict __stream,
>     const char *__restrict __format, ...) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int scanf (const char *__restrict __format, ...) __attribute__ ((__warn_unused_result__));
>
>extern int sscanf (const char *__restrict __s,
>     const char *__restrict __format, ...) __attribute__ ((__nothrow__ , __leaf__));
># 463 "/usr/include/stdio.h" 3 4
>
>
>
>
>
>
>
>
>extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
>      __gnuc_va_list __arg)
>     __attribute__ ((__format__ (__scanf__, 2, 0))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
>     __attribute__ ((__format__ (__scanf__, 1, 0))) __attribute__ ((__warn_unused_result__));
>
>
>extern int vsscanf (const char *__restrict __s,
>      const char *__restrict __format, __gnuc_va_list __arg)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__scanf__, 2, 0)));
># 522 "/usr/include/stdio.h" 3 4
>
>
>
>
>
>
>
>
>
>extern int fgetc (FILE *__stream);
>extern int getc (FILE *__stream);
>
>
>
>
>
>extern int getchar (void);
>
># 550 "/usr/include/stdio.h" 3 4
>extern int getc_unlocked (FILE *__stream);
>extern int getchar_unlocked (void);
># 561 "/usr/include/stdio.h" 3 4
>extern int fgetc_unlocked (FILE *__stream);
>
>
>
>
>
>
>
>
>
>
>
>extern int fputc (int __c, FILE *__stream);
>extern int putc (int __c, FILE *__stream);
>
>
>
>
>
>extern int putchar (int __c);
>
># 594 "/usr/include/stdio.h" 3 4
>extern int fputc_unlocked (int __c, FILE *__stream);
>
>
>
>
>
>
>
>extern int putc_unlocked (int __c, FILE *__stream);
>extern int putchar_unlocked (int __c);
>
>
>
>
>
>
>extern int getw (FILE *__stream);
>
>
>extern int putw (int __w, FILE *__stream);
>
>
>
>
>
>
>
>
>extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
>     __attribute__ ((__warn_unused_result__));
># 640 "/usr/include/stdio.h" 3 4
>
># 649 "/usr/include/stdio.h" 3 4
>extern char *fgets_unlocked (char *__restrict __s, int __n,
>        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
># 665 "/usr/include/stdio.h" 3 4
>extern __ssize_t __getdelim (char **__restrict __lineptr,
>          size_t *__restrict __n, int __delimiter,
>          FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>extern __ssize_t getdelim (char **__restrict __lineptr,
>        size_t *__restrict __n, int __delimiter,
>        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>extern __ssize_t getline (char **__restrict __lineptr,
>       size_t *__restrict __n,
>       FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>
>extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
>
>
>
>
>
>extern int puts (const char *__s);
>
>
>
>
>
>
>extern int ungetc (int __c, FILE *__stream);
>
>
>
>
>
>
>extern size_t fread (void *__restrict __ptr, size_t __size,
>       size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern size_t fwrite (const void *__restrict __ptr, size_t __size,
>        size_t __n, FILE *__restrict __s);
>
># 726 "/usr/include/stdio.h" 3 4
>extern int fputs_unlocked (const char *__restrict __s,
>      FILE *__restrict __stream);
># 737 "/usr/include/stdio.h" 3 4
>extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
>         size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
>          size_t __n, FILE *__restrict __stream);
>
>
>
>
>
>
>
>
>extern int fseek (FILE *__stream, long int __off, int __whence);
>
>
>
>
>extern long int ftell (FILE *__stream) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern void rewind (FILE *__stream);
>
># 781 "/usr/include/stdio.h" 3 4
>extern int fseeko (FILE *__stream, __off64_t __off, int __whence) __asm__ ("" "fseeko64")
>
>                  ;
>extern __off64_t ftello (FILE *__stream) __asm__ ("" "ftello64");
>
>
>
>
>
>
>
>
># 806 "/usr/include/stdio.h" 3 4
>extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos) __asm__ ("" "fgetpos64")
>                                          ;
>extern int fsetpos (FILE *__stream, const fpos_t *__pos) __asm__ ("" "fsetpos64")
>                                                          ;
>
>
>
>
>
>
>
>
>extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
>extern __off64_t ftello64 (FILE *__stream) __attribute__ ((__warn_unused_result__));
>extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
>extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos);
>
>
>
>
>extern void clearerr (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
>
>extern int feof (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>extern int ferror (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern void clearerr_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
>extern int feof_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>extern int ferror_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>
>extern void perror (const char *__s);
>
>
>
>
>
>
># 1 "/usr/include/bits/sys_errlist.h" 1 3 4
># 26 "/usr/include/bits/sys_errlist.h" 3 4
>extern int sys_nerr;
>extern const char *const sys_errlist[];
>
>
>extern int _sys_nerr;
>extern const char *const _sys_errlist[];
># 854 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>extern int fileno (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int fileno_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
># 872 "/usr/include/stdio.h" 3 4
>extern FILE *popen (const char *__command, const char *__modes) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int pclose (FILE *__stream);
>
>
>
>
>
>extern char *ctermid (char *__s) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern char *cuserid (char *__s);
>
>
>
>
>struct obstack;
>
>
>extern int obstack_printf (struct obstack *__restrict __obstack,
>      const char *__restrict __format, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 3)));
>extern int obstack_vprintf (struct obstack *__restrict __obstack,
>       const char *__restrict __format,
>       __gnuc_va_list __args)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 0)));
>
>
>
>
>
>
>
>extern void flockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int ftrylockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>extern void funlockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
># 933 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/bits/stdio.h" 1 3 4
># 43 "/usr/include/bits/stdio.h" 3 4
>extern __inline int
>getchar (void)
>{
>  return _IO_getc (stdin);
>}
>
>
>
>
>extern __inline int
>fgetc_unlocked (FILE *__fp)
>{
>  return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
>}
>
>
>
>
>
>extern __inline int
>getc_unlocked (FILE *__fp)
>{
>  return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
>}
>
>
>extern __inline int
>getchar_unlocked (void)
>{
>  return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
>}
>
>
>
>
>extern __inline int
>putchar (int __c)
>{
>  return _IO_putc (__c, stdout);
>}
>
>
>
>
>extern __inline int
>fputc_unlocked (int __c, FILE *__stream)
>{
>  return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
>}
>
>
>
>
>
>extern __inline int
>putc_unlocked (int __c, FILE *__stream)
>{
>  return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
>}
>
>
>extern __inline int
>putchar_unlocked (int __c)
>{
>  return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
>}
>
>
>
>
>
>extern __inline __ssize_t
>getline (char **__lineptr, size_t *__n, FILE *__stream)
>{
>  return __getdelim (__lineptr, __n, '\n', __stream);
>}
>
>
>
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) feof_unlocked (FILE *__stream)
>{
>  return (((__stream)->_flags & 0x10) != 0);
>}
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) ferror_unlocked (FILE *__stream)
>{
>  return (((__stream)->_flags & 0x20) != 0);
>}
># 934 "/usr/include/stdio.h" 2 3 4
>
>
># 1 "/usr/include/bits/stdio2.h" 1 3 4
># 23 "/usr/include/bits/stdio2.h" 3 4
>extern int __sprintf_chk (char *__restrict __s, int __flag, size_t __slen,
>     const char *__restrict __format, ...) __attribute__ ((__nothrow__ , __leaf__));
>extern int __vsprintf_chk (char *__restrict __s, int __flag, size_t __slen,
>      const char *__restrict __format,
>      __gnuc_va_list __ap) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) sprintf (char *__restrict __s, const char *__restrict __fmt, ...)
>{
>  return __builtin___sprintf_chk (__s, 2 - 1,
>      __builtin_object_size (__s, 2 > 1), __fmt, __builtin_va_arg_pack ());
>}
>
>
>
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) vsprintf (char *__restrict __s, const char *__restrict __fmt, __gnuc_va_list __ap)
>
>{
>  return __builtin___vsprintf_chk (__s, 2 - 1,
>       __builtin_object_size (__s, 2 > 1), __fmt, __ap);
>}
>
>
>
>extern int __snprintf_chk (char *__restrict __s, size_t __n, int __flag,
>      size_t __slen, const char *__restrict __format,
>      ...) __attribute__ ((__nothrow__ , __leaf__));
>extern int __vsnprintf_chk (char *__restrict __s, size_t __n, int __flag,
>       size_t __slen, const char *__restrict __format,
>       __gnuc_va_list __ap) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) snprintf (char *__restrict __s, size_t __n, const char *__restrict __fmt, ...)
>
>{
>  return __builtin___snprintf_chk (__s, __n, 2 - 1,
>       __builtin_object_size (__s, 2 > 1), __fmt, __builtin_va_arg_pack ());
>}
>
>
>
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) vsnprintf (char *__restrict __s, size_t __n, const char *__restrict __fmt, __gnuc_va_list __ap)
>
>{
>  return __builtin___vsnprintf_chk (__s, __n, 2 - 1,
>        __builtin_object_size (__s, 2 > 1), __fmt, __ap);
>}
>
>
>
>
>
>extern int __fprintf_chk (FILE *__restrict __stream, int __flag,
>     const char *__restrict __format, ...);
>extern int __printf_chk (int __flag, const char *__restrict __format, ...);
>extern int __vfprintf_chk (FILE *__restrict __stream, int __flag,
>      const char *__restrict __format, __gnuc_va_list __ap);
>extern int __vprintf_chk (int __flag, const char *__restrict __format,
>     __gnuc_va_list __ap);
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>fprintf (FILE *__restrict __stream, const char *__restrict __fmt, ...)
>{
>  return __fprintf_chk (__stream, 2 - 1, __fmt,
>   __builtin_va_arg_pack ());
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>printf (const char *__restrict __fmt, ...)
>{
>  return __printf_chk (2 - 1, __fmt, __builtin_va_arg_pack ());
>}
>
>
>
>
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>vprintf (const char *__restrict __fmt, __gnuc_va_list __ap)
>{
>
>  return __vfprintf_chk (stdout, 2 - 1, __fmt, __ap);
>
>
>
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>vfprintf (FILE *__restrict __stream,
>   const char *__restrict __fmt, __gnuc_va_list __ap)
>{
>  return __vfprintf_chk (__stream, 2 - 1, __fmt, __ap);
>}
>
>
>extern int __dprintf_chk (int __fd, int __flag, const char *__restrict __fmt,
>     ...) __attribute__ ((__format__ (__printf__, 3, 4)));
>extern int __vdprintf_chk (int __fd, int __flag,
>      const char *__restrict __fmt, __gnuc_va_list __arg)
>     __attribute__ ((__format__ (__printf__, 3, 0)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>dprintf (int __fd, const char *__restrict __fmt, ...)
>{
>  return __dprintf_chk (__fd, 2 - 1, __fmt,
>   __builtin_va_arg_pack ());
>}
>
>
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>vdprintf (int __fd, const char *__restrict __fmt, __gnuc_va_list __ap)
>{
>  return __vdprintf_chk (__fd, 2 - 1, __fmt, __ap);
>}
>
>
>
>
>extern int __asprintf_chk (char **__restrict __ptr, int __flag,
>      const char *__restrict __fmt, ...)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__printf__, 3, 4))) __attribute__ ((__warn_unused_result__));
>extern int __vasprintf_chk (char **__restrict __ptr, int __flag,
>       const char *__restrict __fmt, __gnuc_va_list __arg)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__printf__, 3, 0))) __attribute__ ((__warn_unused_result__));
>extern int __obstack_printf_chk (struct obstack *__restrict __obstack,
>     int __flag, const char *__restrict __format,
>     ...)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__printf__, 3, 4)));
>extern int __obstack_vprintf_chk (struct obstack *__restrict __obstack,
>      int __flag,
>      const char *__restrict __format,
>      __gnuc_va_list __args)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__printf__, 3, 0)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) asprintf (char **__restrict __ptr, const char *__restrict __fmt, ...)
>{
>  return __asprintf_chk (__ptr, 2 - 1, __fmt,
>    __builtin_va_arg_pack ());
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) __asprintf (char **__restrict __ptr, const char *__restrict __fmt, ...)
>
>{
>  return __asprintf_chk (__ptr, 2 - 1, __fmt,
>    __builtin_va_arg_pack ());
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) obstack_printf (struct obstack *__restrict __obstack, const char *__restrict __fmt, ...)
>
>{
>  return __obstack_printf_chk (__obstack, 2 - 1, __fmt,
>          __builtin_va_arg_pack ());
>}
># 206 "/usr/include/bits/stdio2.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) vasprintf (char **__restrict __ptr, const char *__restrict __fmt, __gnuc_va_list __ap)
>
>{
>  return __vasprintf_chk (__ptr, 2 - 1, __fmt, __ap);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) obstack_vprintf (struct obstack *__restrict __obstack, const char *__restrict __fmt, __gnuc_va_list __ap)
>
>{
>  return __obstack_vprintf_chk (__obstack, 2 - 1, __fmt,
>    __ap);
>}
># 241 "/usr/include/bits/stdio2.h" 3 4
>extern char *__fgets_chk (char *__restrict __s, size_t __size, int __n,
>     FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>extern char *__fgets_alias (char *__restrict __s, int __n, FILE *__restrict __stream) __asm__ ("" "fgets")
>
>                                        __attribute__ ((__warn_unused_result__));
>extern char *__fgets_chk_warn (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __asm__ ("" "__fgets_chk")
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgets called with bigger size than length " "of destination buffer")))
>                                 ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
>fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
>{
>  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__n) || __n <= 0)
> return __fgets_chk (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
>
>      if ((size_t) __n > __builtin_object_size (__s, 2 > 1))
> return __fgets_chk_warn (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
>    }
>  return __fgets_alias (__s, __n, __stream);
>}
>
>extern size_t __fread_chk (void *__restrict __ptr, size_t __ptrlen,
>      size_t __size, size_t __n,
>      FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>extern size_t __fread_alias (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "fread")
>
>
>            __attribute__ ((__warn_unused_result__));
>extern size_t __fread_chk_warn (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "__fread_chk")
>
>
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fread called with bigger size * nmemb than length " "of destination buffer")))
>                                 ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) size_t
>fread (void *__restrict __ptr, size_t __size, size_t __n,
>       FILE *__restrict __stream)
>{
>  if (__builtin_object_size (__ptr, 0) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__size)
>   || !__builtin_constant_p (__n)
>   || (__size | __n) >= (((size_t) 1) << (8 * sizeof (size_t) / 2)))
> return __fread_chk (__ptr, __builtin_object_size (__ptr, 0), __size, __n, __stream);
>
>      if (__size * __n > __builtin_object_size (__ptr, 0))
> return __fread_chk_warn (__ptr, __builtin_object_size (__ptr, 0), __size, __n, __stream);
>    }
>  return __fread_alias (__ptr, __size, __n, __stream);
>}
>
>
>extern char *__fgets_unlocked_chk (char *__restrict __s, size_t __size,
>       int __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>extern char *__fgets_unlocked_alias (char *__restrict __s, int __n, FILE *__restrict __stream) __asm__ ("" "fgets_unlocked")
>
>                                                 __attribute__ ((__warn_unused_result__));
>extern char *__fgets_unlocked_chk_warn (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __asm__ ("" "__fgets_unlocked_chk")
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgets_unlocked called with bigger size than length " "of destination buffer")))
>                                 ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
>fgets_unlocked (char *__restrict __s, int __n, FILE *__restrict __stream)
>{
>  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__n) || __n <= 0)
> return __fgets_unlocked_chk (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
>
>      if ((size_t) __n > __builtin_object_size (__s, 2 > 1))
> return __fgets_unlocked_chk_warn (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
>    }
>  return __fgets_unlocked_alias (__s, __n, __stream);
>}
>
>
>
>
>extern size_t __fread_unlocked_chk (void *__restrict __ptr, size_t __ptrlen,
>        size_t __size, size_t __n,
>        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
>extern size_t __fread_unlocked_alias (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "fread_unlocked")
>
>
>                     __attribute__ ((__warn_unused_result__));
>extern size_t __fread_unlocked_chk_warn (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "__fread_unlocked_chk")
>
>
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fread_unlocked called with bigger size * nmemb than " "length of destination buffer")))
>                                        ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) size_t
>fread_unlocked (void *__restrict __ptr, size_t __size, size_t __n,
>  FILE *__restrict __stream)
>{
>  if (__builtin_object_size (__ptr, 0) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__size)
>   || !__builtin_constant_p (__n)
>   || (__size | __n) >= (((size_t) 1) << (8 * sizeof (size_t) / 2)))
> return __fread_unlocked_chk (__ptr, __builtin_object_size (__ptr, 0), __size, __n,
>         __stream);
>
>      if (__size * __n > __builtin_object_size (__ptr, 0))
> return __fread_unlocked_chk_warn (__ptr, __builtin_object_size (__ptr, 0), __size, __n,
>       __stream);
>    }
>
>
>  if (__builtin_constant_p (__size)
>      && __builtin_constant_p (__n)
>      && (__size | __n) < (((size_t) 1) << (8 * sizeof (size_t) / 2))
>      && __size * __n <= 8)
>    {
>      size_t __cnt = __size * __n;
>      char *__cptr = (char *) __ptr;
>      if (__cnt == 0)
> return 0;
>
>      for (; __cnt > 0; --__cnt)
> {
>   int __c = (__builtin_expect (((__stream)->_IO_read_ptr >= (__stream)->_IO_read_end), 0) ? __uflow (__stream) : *(unsigned char *) (__stream)->_IO_read_ptr++);
>   if (__c == (-1))
>     break;
>   *__cptr++ = __c;
> }
>      return (__cptr - (char *) __ptr) / __size;
>    }
>
>  return __fread_unlocked_alias (__ptr, __size, __n, __stream);
>}
># 937 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>
>
># 52 "hstdinc.h" 2
># 1 "/usr/include/stdlib.h" 1 3 4
># 32 "/usr/include/stdlib.h" 3 4
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 324 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stddef.h" 3 4
>typedef long int wchar_t;
># 33 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>
>
>
>
># 1 "/usr/include/bits/waitflags.h" 1 3 4
># 42 "/usr/include/stdlib.h" 2 3 4
># 1 "/usr/include/bits/waitstatus.h" 1 3 4
># 64 "/usr/include/bits/waitstatus.h" 3 4
># 1 "/usr/include/endian.h" 1 3 4
># 36 "/usr/include/endian.h" 3 4
># 1 "/usr/include/bits/endian.h" 1 3 4
># 37 "/usr/include/endian.h" 2 3 4
># 60 "/usr/include/endian.h" 3 4
># 1 "/usr/include/bits/byteswap.h" 1 3 4
># 28 "/usr/include/bits/byteswap.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/usr/include/bits/byteswap.h" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/bits/byteswap-16.h" 1 3 4
># 36 "/usr/include/bits/byteswap.h" 2 3 4
># 44 "/usr/include/bits/byteswap.h" 3 4
>static __inline unsigned int
>__bswap_32 (unsigned int __bsx)
>{
>  return __builtin_bswap32 (__bsx);
>}
># 108 "/usr/include/bits/byteswap.h" 3 4
>static __inline __uint64_t
>__bswap_64 (__uint64_t __bsx)
>{
>  return __builtin_bswap64 (__bsx);
>}
># 61 "/usr/include/endian.h" 2 3 4
># 65 "/usr/include/bits/waitstatus.h" 2 3 4
>
>union wait
>  {
>    int w_status;
>    struct
>      {
>
> unsigned int __w_termsig:7;
> unsigned int __w_coredump:1;
> unsigned int __w_retcode:8;
> unsigned int:16;
>
>
>
>
>
>
>
>      } __wait_terminated;
>    struct
>      {
>
> unsigned int __w_stopval:8;
> unsigned int __w_stopsig:8;
> unsigned int:16;
>
>
>
>
>
>
>      } __wait_stopped;
>  };
># 43 "/usr/include/stdlib.h" 2 3 4
># 67 "/usr/include/stdlib.h" 3 4
>typedef union
>  {
>    union wait *__uptr;
>    int *__iptr;
>  } __WAIT_STATUS __attribute__ ((__transparent_union__));
># 95 "/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;
>
>
># 139 "/usr/include/stdlib.h" 3 4
>extern size_t __ctype_get_mb_cur_max (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern double atof (const char *__nptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>extern int atoi (const char *__nptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>extern long int atol (const char *__nptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>__extension__ extern long long int atoll (const char *__nptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern double strtod (const char *__restrict __nptr,
>        char **__restrict __endptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern float strtof (const char *__restrict __nptr,
>       char **__restrict __endptr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>extern long double strtold (const char *__restrict __nptr,
>       char **__restrict __endptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern long int strtol (const char *__restrict __nptr,
>   char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>extern unsigned long int strtoul (const char *__restrict __nptr,
>      char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>__extension__
>extern long long int strtoq (const char *__restrict __nptr,
>        char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>__extension__
>extern unsigned long long int strtouq (const char *__restrict __nptr,
>           char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>__extension__
>extern long long int strtoll (const char *__restrict __nptr,
>         char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>__extension__
>extern unsigned long long int strtoull (const char *__restrict __nptr,
>     char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
># 235 "/usr/include/stdlib.h" 3 4
># 1 "/usr/include/xlocale.h" 1 3 4
># 27 "/usr/include/xlocale.h" 3 4
>typedef struct __locale_struct
>{
>
>  struct __locale_data *__locales[13];
>
>
>  const unsigned short int *__ctype_b;
>  const int *__ctype_tolower;
>  const int *__ctype_toupper;
>
>
>  const char *__names[13];
>} *__locale_t;
>
>
>typedef __locale_t locale_t;
># 236 "/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__ , __leaf__)) __attribute__ ((__nonnull__ (1, 4)));
>
>extern unsigned long int strtoul_l (const char *__restrict __nptr,
>        char **__restrict __endptr,
>        int __base, __locale_t __loc)
>     __attribute__ ((__nothrow__ , __leaf__)) __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__ , __leaf__)) __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__ , __leaf__)) __attribute__ ((__nonnull__ (1, 4)));
>
>extern double strtod_l (const char *__restrict __nptr,
>   char **__restrict __endptr, __locale_t __loc)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 3)));
>
>extern float strtof_l (const char *__restrict __nptr,
>         char **__restrict __endptr, __locale_t __loc)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 3)));
>
>extern long double strtold_l (const char *__restrict __nptr,
>         char **__restrict __endptr,
>         __locale_t __loc)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) atoi (const char *__nptr)
>{
>  return (int) strtol (__nptr, (char **) ((void *)0), 10);
>}
>extern __inline long int
>__attribute__ ((__nothrow__ , __leaf__)) atol (const char *__nptr)
>{
>  return strtol (__nptr, (char **) ((void *)0), 10);
>}
>
>
>
>
>__extension__ extern __inline long long int
>__attribute__ ((__nothrow__ , __leaf__)) atoll (const char *__nptr)
>{
>  return strtoll (__nptr, (char **) ((void *)0), 10);
>}
>
># 305 "/usr/include/stdlib.h" 3 4
>extern char *l64a (long int __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>extern long int a64l (const char *__s)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
># 1 "/usr/include/sys/types.h" 1 3 4
># 27 "/usr/include/sys/types.h" 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;
># 98 "/usr/include/sys/types.h" 3 4
>typedef __pid_t pid_t;
>
>
>
>
>
>typedef __id_t id_t;
># 115 "/usr/include/sys/types.h" 3 4
>typedef __daddr_t daddr_t;
>typedef __caddr_t caddr_t;
>
>
>
>
>
>typedef __key_t key_t;
># 132 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/time.h" 1 3 4
># 57 "/usr/include/time.h" 3 4
>
>
>typedef __clock_t clock_t;
>
>
>
># 73 "/usr/include/time.h" 3 4
>
>
>typedef __time_t time_t;
>
>
>
># 91 "/usr/include/time.h" 3 4
>typedef __clockid_t clockid_t;
># 103 "/usr/include/time.h" 3 4
>typedef __timer_t timer_t;
># 133 "/usr/include/sys/types.h" 2 3 4
>
>
>
>typedef __useconds_t useconds_t;
>
>
>
>typedef __suseconds_t suseconds_t;
>
>
>
>
>
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 147 "/usr/include/sys/types.h" 2 3 4
>
>
>
>typedef unsigned long int ulong;
>typedef unsigned short int ushort;
>typedef unsigned int uint;
># 194 "/usr/include/sys/types.h" 3 4
>typedef int int8_t __attribute__ ((__mode__ (__QI__)));
>typedef int int16_t __attribute__ ((__mode__ (__HI__)));
>typedef int int32_t __attribute__ ((__mode__ (__SI__)));
>typedef int int64_t __attribute__ ((__mode__ (__DI__)));
>
>
>typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
>typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
>typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
>typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
>
>typedef int register_t __attribute__ ((__mode__ (__word__)));
># 219 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/sys/select.h" 1 3 4
># 30 "/usr/include/sys/select.h" 3 4
># 1 "/usr/include/bits/select.h" 1 3 4
># 22 "/usr/include/bits/select.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 23 "/usr/include/bits/select.h" 2 3 4
># 31 "/usr/include/sys/select.h" 2 3 4
>
>
># 1 "/usr/include/bits/sigset.h" 1 3 4
># 22 "/usr/include/bits/sigset.h" 3 4
>typedef int __sig_atomic_t;
>
>
>
>
>typedef struct
>  {
>    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
>  } __sigset_t;
># 34 "/usr/include/sys/select.h" 2 3 4
>
>
>
>typedef __sigset_t sigset_t;
>
>
>
>
>
># 1 "/usr/include/time.h" 1 3 4
># 120 "/usr/include/time.h" 3 4
>struct timespec
>  {
>    __time_t tv_sec;
>    __syscall_slong_t tv_nsec;
>  };
># 44 "/usr/include/sys/select.h" 2 3 4
>
># 1 "/usr/include/bits/time.h" 1 3 4
># 30 "/usr/include/bits/time.h" 3 4
>struct timeval
>  {
>    __time_t tv_sec;
>    __suseconds_t tv_usec;
>  };
># 46 "/usr/include/sys/select.h" 2 3 4
># 54 "/usr/include/sys/select.h" 3 4
>typedef long int __fd_mask;
># 64 "/usr/include/sys/select.h" 3 4
>typedef struct
>  {
>
>
>
>    __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
>
>
>
>
>
>  } fd_set;
>
>
>
>
>
>
>typedef __fd_mask fd_mask;
># 96 "/usr/include/sys/select.h" 3 4
>
># 106 "/usr/include/sys/select.h" 3 4
>extern int select (int __nfds, fd_set *__restrict __readfds,
>     fd_set *__restrict __writefds,
>     fd_set *__restrict __exceptfds,
>     struct timeval *__restrict __timeout);
># 118 "/usr/include/sys/select.h" 3 4
>extern int pselect (int __nfds, fd_set *__restrict __readfds,
>      fd_set *__restrict __writefds,
>      fd_set *__restrict __exceptfds,
>      const struct timespec *__restrict __timeout,
>      const __sigset_t *__restrict __sigmask);
>
>
>
>
>
># 1 "/usr/include/bits/select2.h" 1 3 4
># 24 "/usr/include/bits/select2.h" 3 4
>extern long int __fdelt_chk (long int __d);
>extern long int __fdelt_warn (long int __d)
>  __attribute__((__warning__ ("bit outside of fd_set selected")));
># 129 "/usr/include/sys/select.h" 2 3 4
>
>
>
># 220 "/usr/include/sys/types.h" 2 3 4
>
>
># 1 "/usr/include/sys/sysmacros.h" 1 3 4
># 24 "/usr/include/sys/sysmacros.h" 3 4
>
>
>__extension__
>extern unsigned int gnu_dev_major (unsigned long long int __dev)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>__extension__
>extern unsigned int gnu_dev_minor (unsigned long long int __dev)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>__extension__
>extern unsigned long long int gnu_dev_makedev (unsigned int __major,
>            unsigned int __minor)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>__extension__ extern __inline __attribute__ ((__const__)) unsigned int
>__attribute__ ((__nothrow__ , __leaf__)) gnu_dev_major (unsigned long long int __dev)
>{
>  return ((__dev >> 8) & 0xfff) | ((unsigned int) (__dev >> 32) & ~0xfff);
>}
>
>__extension__ extern __inline __attribute__ ((__const__)) unsigned int
>__attribute__ ((__nothrow__ , __leaf__)) gnu_dev_minor (unsigned long long int __dev)
>{
>  return (__dev & 0xff) | ((unsigned int) (__dev >> 12) & ~0xff);
>}
>
>__extension__ extern __inline __attribute__ ((__const__)) unsigned long long int
>__attribute__ ((__nothrow__ , __leaf__)) gnu_dev_makedev (unsigned int __major, unsigned int __minor)
>{
>  return ((__minor & 0xff) | ((__major & 0xfff) << 8)
>   | (((unsigned long long int) (__minor & ~0xff)) << 12)
>   | (((unsigned long long int) (__major & ~0xfff)) << 32));
>}
>
>
># 223 "/usr/include/sys/types.h" 2 3 4
>
>
>
>
>
>typedef __blksize_t blksize_t;
># 248 "/usr/include/sys/types.h" 3 4
>typedef __blkcnt64_t blkcnt_t;
>
>
>
>typedef __fsblkcnt64_t fsblkcnt_t;
>
>
>
>typedef __fsfilcnt64_t fsfilcnt_t;
>
>
>
>
>
>typedef __blkcnt64_t blkcnt64_t;
>typedef __fsblkcnt64_t fsblkcnt64_t;
>typedef __fsfilcnt64_t fsfilcnt64_t;
>
>
>
>
>
># 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
># 21 "/usr/include/bits/pthreadtypes.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 22 "/usr/include/bits/pthreadtypes.h" 2 3 4
># 60 "/usr/include/bits/pthreadtypes.h" 3 4
>typedef unsigned long int pthread_t;
>
>
>union pthread_attr_t
>{
>  char __size[36];
>  long int __align;
>};
>
>typedef union pthread_attr_t pthread_attr_t;
># 81 "/usr/include/bits/pthreadtypes.h" 3 4
>typedef struct __pthread_internal_slist
>{
>  struct __pthread_internal_slist *__next;
>} __pthread_slist_t;
>
>
>
>
>
>typedef union
>{
>  struct __pthread_mutex_s
>  {
>    int __lock;
>    unsigned int __count;
>    int __owner;
>
>
>
>
>
>    int __kind;
># 111 "/usr/include/bits/pthreadtypes.h" 3 4
>    unsigned int __nusers;
>    __extension__ union
>    {
>      struct
>      {
> short __espins;
> short __elision;
>
>
>
>      } __elision_data;
>      __pthread_slist_t __list;
>    };
>
>  } __data;
>  char __size[24];
>  long int __align;
>} pthread_mutex_t;
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_mutexattr_t;
>
>
>
>
>typedef union
>{
>  struct
>  {
>    int __lock;
>    unsigned int __futex;
>    __extension__ unsigned long long int __total_seq;
>    __extension__ unsigned long long int __wakeup_seq;
>    __extension__ unsigned long long int __woken_seq;
>    void *__mutex;
>    unsigned int __nwaiters;
>    unsigned int __broadcast_seq;
>  } __data;
>  char __size[48];
>  __extension__ long long int __align;
>} pthread_cond_t;
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_condattr_t;
>
>
>
>typedef unsigned int pthread_key_t;
>
>
>
>typedef int pthread_once_t;
>
>
>
>
>
>typedef union
>{
># 202 "/usr/include/bits/pthreadtypes.h" 3 4
>  struct
>  {
>    int __lock;
>    unsigned int __nr_readers;
>    unsigned int __readers_wakeup;
>    unsigned int __writer_wakeup;
>    unsigned int __nr_readers_queued;
>    unsigned int __nr_writers_queued;
>
>
>    unsigned char __flags;
>    unsigned char __shared;
>    signed char __rwelision;
>
>    unsigned char __pad2;
>    int __writer;
>  } __data;
>
>  char __size[32];
>  long int __align;
>} pthread_rwlock_t;
>
>typedef union
>{
>  char __size[8];
>  long int __align;
>} pthread_rwlockattr_t;
>
>
>
>
>
>typedef volatile int pthread_spinlock_t;
>
>
>
>
>typedef union
>{
>  char __size[20];
>  long int __align;
>} pthread_barrier_t;
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_barrierattr_t;
># 271 "/usr/include/sys/types.h" 2 3 4
>
>
>
># 315 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>
>
>extern long int random (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern void srandom (unsigned int __seed) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern char *initstate (unsigned int __seed, char *__statebuf,
>   size_t __statelen) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>extern char *setstate (char *__statebuf) __attribute__ ((__nothrow__ , __leaf__)) __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__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int srandom_r (unsigned int __seed, struct random_data *__buf)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
>   size_t __statelen,
>   struct random_data *__restrict __buf)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 4)));
>
>extern int setstate_r (char *__restrict __statebuf,
>         struct random_data *__restrict __buf)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern int rand (void) __attribute__ ((__nothrow__ , __leaf__));
>
>extern void srand (unsigned int __seed) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int rand_r (unsigned int *__seed) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern double drand48 (void) __attribute__ ((__nothrow__ , __leaf__));
>extern double erand48 (unsigned short int __xsubi[3]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern long int lrand48 (void) __attribute__ ((__nothrow__ , __leaf__));
>extern long int nrand48 (unsigned short int __xsubi[3])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern long int mrand48 (void) __attribute__ ((__nothrow__ , __leaf__));
>extern long int jrand48 (unsigned short int __xsubi[3])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern void srand48 (long int __seedval) __attribute__ ((__nothrow__ , __leaf__));
>extern unsigned short int *seed48 (unsigned short int __seed16v[3])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>extern void lcong48 (unsigned short int __param[7]) __attribute__ ((__nothrow__ , __leaf__)) __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__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>extern int erand48_r (unsigned short int __xsubi[3],
>        struct drand48_data *__restrict __buffer,
>        double *__restrict __result) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int lrand48_r (struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>extern int nrand48_r (unsigned short int __xsubi[3],
>        struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int mrand48_r (struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>extern int jrand48_r (unsigned short int __xsubi[3],
>        struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>extern int seed48_r (unsigned short int __seed16v[3],
>       struct drand48_data *__buffer) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int lcong48_r (unsigned short int __param[7],
>        struct drand48_data *__buffer)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>
>
>
>extern void *malloc (size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
>extern void *calloc (size_t __nmemb, size_t __size)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>
>
>
>extern void *realloc (void *__ptr, size_t __size)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>extern void free (void *__ptr) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern void cfree (void *__ptr) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
># 1 "/usr/include/alloca.h" 1 3 4
># 24 "/usr/include/alloca.h" 3 4
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 25 "/usr/include/alloca.h" 2 3 4
>
>
>
>
>
>
>
>extern void *alloca (size_t __size) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
># 493 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>
>extern void *valloc (size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern void *aligned_alloc (size_t __alignment, size_t __size)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern void abort (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
>
>
>
>extern int atexit (void (*__func) (void)) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int at_quick_exit (void (*__func) (void)) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern void exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
>
>
>
>
>
>extern void quick_exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
>
>
>
>
>
>
>
>extern void _Exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
>
>
>
>
>
>
>extern char *getenv (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern char *secure_getenv (const char *__name)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern int putenv (char *__string) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int setenv (const char *__name, const char *__value, int __replace)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>extern int unsetenv (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int clearenv (void) __attribute__ ((__nothrow__ , __leaf__));
># 606 "/usr/include/stdlib.h" 3 4
>extern char *mktemp (char *__template) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 622 "/usr/include/stdlib.h" 3 4
>extern int mkstemp (char *__template) __asm__ ("" "mkstemp64")
>     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 644 "/usr/include/stdlib.h" 3 4
>extern int mkstemps (char *__template, int __suffixlen) __asm__ ("" "mkstemps64")
>                     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int mkstemps64 (char *__template, int __suffixlen)
>     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 662 "/usr/include/stdlib.h" 3 4
>extern char *mkdtemp (char *__template) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 676 "/usr/include/stdlib.h" 3 4
>extern int mkostemp (char *__template, int __flags) __asm__ ("" "mkostemp64")
>     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 697 "/usr/include/stdlib.h" 3 4
>extern int mkostemps (char *__template, int __suffixlen, int __flags) __asm__ ("" "mkostemps64")
>
>     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
>     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>
>
>extern int system (const char *__command) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern char *canonicalize_file_name (const char *__name)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 733 "/usr/include/stdlib.h" 3 4
>extern char *realpath (const char *__restrict __name,
>         char *__restrict __resolved) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>typedef int (*__compar_fn_t) (const void *, const void *);
>
>
>typedef __compar_fn_t comparison_fn_t;
>
>
>
>typedef int (*__compar_d_fn_t) (const void *, const void *, void *);
>
>
>
>
>
>extern void *bsearch (const void *__key, const void *__base,
>        size_t __nmemb, size_t __size, __compar_fn_t __compar)
>     __attribute__ ((__nonnull__ (1, 2, 5))) __attribute__ ((__warn_unused_result__));
>
>
># 1 "/usr/include/bits/stdlib-bsearch.h" 1 3 4
># 19 "/usr/include/bits/stdlib-bsearch.h" 3 4
>extern __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 = (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);
>}
># 760 "/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__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>extern long int labs (long int __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>
>
>
>__extension__ extern long long int llabs (long long int __x)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>extern div_t div (int __numer, int __denom)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>extern ldiv_t ldiv (long int __numer, long int __denom)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>__extension__ extern lldiv_t lldiv (long long int __numer,
>        long long int __denom)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
>
># 811 "/usr/include/stdlib.h" 3 4
>extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern char *gcvt (double __value, int __ndigit, char *__buf)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern char *qecvt (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
>extern char *qfcvt (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
>extern char *qgcvt (long double __value, int __ndigit, char *__buf)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign, char *__restrict __buf,
>     size_t __len) __attribute__ ((__nothrow__ , __leaf__)) __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__ , __leaf__)) __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__ , __leaf__)) __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__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
>
>
>
>
>
>
>extern int mblen (const char *__s, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int mbtowc (wchar_t *__restrict __pwc,
>     const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int wctomb (char *__s, wchar_t __wchar) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern size_t mbstowcs (wchar_t *__restrict __pwcs,
>   const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
>
>extern size_t wcstombs (char *__restrict __s,
>   const wchar_t *__restrict __pwcs, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern int rpmatch (const char *__response) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 898 "/usr/include/stdlib.h" 3 4
>extern int getsubopt (char **__restrict __optionp,
>        char *const *__restrict __tokens,
>        char **__restrict __valuep)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2, 3))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern void setkey (const char *__key) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int posix_openpt (int __oflag) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>extern int grantpt (int __fd) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int unlockpt (int __fd) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern char *ptsname (int __fd) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>extern int getpt (void);
>
>
>
>
>
>
>extern int getloadavg (double __loadavg[], int __nelem)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
># 1 "/usr/include/bits/stdlib-float.h" 1 3 4
># 24 "/usr/include/bits/stdlib-float.h" 3 4
>
>extern __inline double
>__attribute__ ((__nothrow__ , __leaf__)) atof (const char *__nptr)
>{
>  return strtod (__nptr, (char **) ((void *)0));
>}
>
># 955 "/usr/include/stdlib.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/stdlib.h" 1 3 4
># 23 "/usr/include/bits/stdlib.h" 3 4
>extern char *__realpath_chk (const char *__restrict __name,
>        char *__restrict __resolved,
>        size_t __resolvedlen) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>extern char *__realpath_alias (const char *__restrict __name, char *__restrict __resolved) __asm__ ("" "realpath") __attribute__ ((__nothrow__ , __leaf__))
>
>                                                 __attribute__ ((__warn_unused_result__));
>extern char *__realpath_chk_warn (const char *__restrict __name, char *__restrict __resolved, size_t __resolvedlen) __asm__ ("" "__realpath_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>                                                __attribute__ ((__warn_unused_result__))
>     __attribute__((__warning__ ("second argument of realpath must be either NULL or at " "least PATH_MAX bytes long buffer")))
>                                      ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) realpath (const char *__restrict __name, char *__restrict __resolved)
>{
>  if (__builtin_object_size (__resolved, 2 > 1) != (size_t) -1)
>    {
>
>
>
>
>      return __realpath_chk (__name, __resolved, __builtin_object_size (__resolved, 2 > 1));
>    }
>
>  return __realpath_alias (__name, __resolved);
>}
>
>
>extern int __ptsname_r_chk (int __fd, char *__buf, size_t __buflen,
>       size_t __nreal) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>extern int __ptsname_r_alias (int __fd, char *__buf, size_t __buflen) __asm__ ("" "ptsname_r") __attribute__ ((__nothrow__ , __leaf__))
>
>     __attribute__ ((__nonnull__ (2)));
>extern int __ptsname_r_chk_warn (int __fd, char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__ptsname_r_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__ ((__nonnull__ (2))) __attribute__((__warning__ ("ptsname_r called with buflen bigger than " "size of buf")))
>                   ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) ptsname_r (int __fd, char *__buf, size_t __buflen)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__buflen))
> return __ptsname_r_chk (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>      if (__buflen > __builtin_object_size (__buf, 2 > 1))
> return __ptsname_r_chk_warn (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __ptsname_r_alias (__fd, __buf, __buflen);
>}
>
>
>extern int __wctomb_chk (char *__s, wchar_t __wchar, size_t __buflen)
>  __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>extern int __wctomb_alias (char *__s, wchar_t __wchar) __asm__ ("" "wctomb") __attribute__ ((__nothrow__ , __leaf__))
>              __attribute__ ((__warn_unused_result__));
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) int
>__attribute__ ((__nothrow__ , __leaf__)) wctomb (char *__s, wchar_t __wchar)
>{
>
>
>
>
>
>
>
>  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 && 16 > __builtin_object_size (__s, 2 > 1))
>    return __wctomb_chk (__s, __wchar, __builtin_object_size (__s, 2 > 1));
>  return __wctomb_alias (__s, __wchar);
>}
>
>
>extern size_t __mbstowcs_chk (wchar_t *__restrict __dst,
>         const char *__restrict __src,
>         size_t __len, size_t __dstlen) __attribute__ ((__nothrow__ , __leaf__));
>extern size_t __mbstowcs_alias (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len) __asm__ ("" "mbstowcs") __attribute__ ((__nothrow__ , __leaf__))
>
>
>                                  ;
>extern size_t __mbstowcs_chk_warn (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len, size_t __dstlen) __asm__ ("" "__mbstowcs_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>
>     __attribute__((__warning__ ("mbstowcs called with dst buffer smaller than len " "* sizeof (wchar_t)")))
>                        ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) size_t
>__attribute__ ((__nothrow__ , __leaf__)) mbstowcs (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len)
>
>{
>  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__len))
> return __mbstowcs_chk (__dst, __src, __len,
>          __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
>
>      if (__len > __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t))
> return __mbstowcs_chk_warn (__dst, __src, __len,
>         __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
>    }
>  return __mbstowcs_alias (__dst, __src, __len);
>}
>
>
>extern size_t __wcstombs_chk (char *__restrict __dst,
>         const wchar_t *__restrict __src,
>         size_t __len, size_t __dstlen) __attribute__ ((__nothrow__ , __leaf__));
>extern size_t __wcstombs_alias (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len) __asm__ ("" "wcstombs") __attribute__ ((__nothrow__ , __leaf__))
>
>
>                                  ;
>extern size_t __wcstombs_chk_warn (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len, size_t __dstlen) __asm__ ("" "__wcstombs_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>
>     __attribute__((__warning__ ("wcstombs called with dst buffer smaller than len")));
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) size_t
>__attribute__ ((__nothrow__ , __leaf__)) wcstombs (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len)
>
>{
>  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__len))
> return __wcstombs_chk (__dst, __src, __len, __builtin_object_size (__dst, 2 > 1));
>      if (__len > __builtin_object_size (__dst, 2 > 1))
> return __wcstombs_chk_warn (__dst, __src, __len, __builtin_object_size (__dst, 2 > 1));
>    }
>  return __wcstombs_alias (__dst, __src, __len);
>}
># 959 "/usr/include/stdlib.h" 2 3 4
># 967 "/usr/include/stdlib.h" 3 4
>
># 53 "hstdinc.h" 2
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stdarg.h" 1 3 4
># 54 "hstdinc.h" 2
># 1 "/usr/include/string.h" 1 3 4
># 27 "/usr/include/string.h" 3 4
>
>
>
>
>
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 33 "/usr/include/string.h" 2 3 4
># 44 "/usr/include/string.h" 3 4
>
>
>extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
>       size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void *memmove (void *__dest, const void *__src, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
>        int __c, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern void *memset (void *__s, int __c, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int memcmp (const void *__s1, const void *__s2, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
># 96 "/usr/include/string.h" 3 4
>extern void *memchr (const void *__s, int __c, size_t __n)
>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
># 110 "/usr/include/string.h" 3 4
>extern void *rawmemchr (const void *__s, int __c)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
># 121 "/usr/include/string.h" 3 4
>extern void *memrchr (const void *__s, int __c, size_t __n)
>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strncpy (char *__restrict __dest,
>        const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *strcat (char *__restrict __dest, const char *__restrict __src)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strncat (char *__restrict __dest, const char *__restrict __src,
>        size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strcmp (const char *__s1, const char *__s2)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int strncmp (const char *__s1, const char *__s2, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strcoll (const char *__s1, const char *__s2)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern size_t strxfrm (char *__restrict __dest,
>         const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
># 166 "/usr/include/string.h" 3 4
>extern int strcoll_l (const char *__s1, const char *__s2, __locale_t __l)
>     __attribute__ ((__nothrow__ , __leaf__)) __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__ , __leaf__)) __attribute__ ((__nonnull__ (2, 4)));
>
>
>
>
>extern char *strdup (const char *__s)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern char *strndup (const char *__string, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
># 210 "/usr/include/string.h" 3 4
>
># 235 "/usr/include/string.h" 3 4
>extern char *strchr (const char *__s, int __c)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
># 262 "/usr/include/string.h" 3 4
>extern char *strrchr (const char *__s, int __c)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
># 276 "/usr/include/string.h" 3 4
>extern char *strchrnul (const char *__s, int __c)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern size_t strcspn (const char *__s, const char *__reject)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern size_t strspn (const char *__s, const char *__accept)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
># 314 "/usr/include/string.h" 3 4
>extern char *strpbrk (const char *__s, const char *__accept)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
># 341 "/usr/include/string.h" 3 4
>extern char *strstr (const char *__haystack, const char *__needle)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern char *strtok (char *__restrict __s, const char *__restrict __delim)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern char *__strtok_r (char *__restrict __s,
>    const char *__restrict __delim,
>    char **__restrict __save_ptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3)));
>
>extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
>         char **__restrict __save_ptr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3)));
># 372 "/usr/include/string.h" 3 4
>extern char *strcasestr (const char *__haystack, const char *__needle)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>
>extern void *memmem (const void *__haystack, size_t __haystacklen,
>       const void *__needle, size_t __needlelen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>extern void *__mempcpy (void *__restrict __dest,
>   const void *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>extern void *mempcpy (void *__restrict __dest,
>        const void *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern size_t strlen (const char *__s)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern size_t strnlen (const char *__string, size_t __maxlen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern char *strerror (int __errnum) __attribute__ ((__nothrow__ , __leaf__));
>
># 437 "/usr/include/string.h" 3 4
>extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern char *strerror_l (int __errnum, __locale_t __l) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern void __bzero (void *__s, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern void bcopy (const void *__src, void *__dest, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void bzero (void *__s, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int bcmp (const void *__s1, const void *__s2, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
># 488 "/usr/include/string.h" 3 4
>extern char *index (const char *__s, int __c)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
># 516 "/usr/include/string.h" 3 4
>extern char *rindex (const char *__s, int __c)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int ffs (int __i) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>extern int ffsl (long int __l) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>__extension__ extern int ffsll (long long int __ll)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern int strcasecmp (const char *__s1, const char *__s2)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int strcasecmp_l (const char *__s1, const char *__s2,
>    __locale_t __loc)
>     __attribute__ ((__nothrow__ , __leaf__)) __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__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
>
>
>
>
>
>extern char *strsep (char **__restrict __stringp,
>       const char *__restrict __delim)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern char *strsignal (int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern char *__stpncpy (char *__restrict __dest,
>   const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>extern char *stpncpy (char *__restrict __dest,
>        const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int strverscmp (const char *__s1, const char *__s2)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *strfry (char *__string) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern void *memfrob (void *__s, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 603 "/usr/include/string.h" 3 4
>extern char *basename (const char *__filename) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 631 "/usr/include/string.h" 3 4
># 1 "/usr/include/bits/string.h" 1 3 4
># 632 "/usr/include/string.h" 2 3 4
>
>
># 1 "/usr/include/bits/string2.h" 1 3 4
># 393 "/usr/include/bits/string2.h" 3 4
>extern void *__rawmemchr (const void *__s, int __c);
># 945 "/usr/include/bits/string2.h" 3 4
>extern __inline size_t __strcspn_c1 (const char *__s, int __reject);
>extern __inline size_t
>__strcspn_c1 (const char *__s, int __reject)
>{
>  size_t __result = 0;
>  while (__s[__result] != '\0' && __s[__result] != __reject)
>    ++__result;
>  return __result;
>}
>
>extern __inline size_t __strcspn_c2 (const char *__s, int __reject1,
>         int __reject2);
>extern __inline size_t
>__strcspn_c2 (const char *__s, int __reject1, int __reject2)
>{
>  size_t __result = 0;
>  while (__s[__result] != '\0' && __s[__result] != __reject1
>  && __s[__result] != __reject2)
>    ++__result;
>  return __result;
>}
>
>extern __inline size_t __strcspn_c3 (const char *__s, int __reject1,
>         int __reject2, int __reject3);
>extern __inline size_t
>__strcspn_c3 (const char *__s, int __reject1, int __reject2,
>       int __reject3)
>{
>  size_t __result = 0;
>  while (__s[__result] != '\0' && __s[__result] != __reject1
>  && __s[__result] != __reject2 && __s[__result] != __reject3)
>    ++__result;
>  return __result;
>}
># 1021 "/usr/include/bits/string2.h" 3 4
>extern __inline size_t __strspn_c1 (const char *__s, int __accept);
>extern __inline size_t
>__strspn_c1 (const char *__s, int __accept)
>{
>  size_t __result = 0;
>
>  while (__s[__result] == __accept)
>    ++__result;
>  return __result;
>}
>
>extern __inline size_t __strspn_c2 (const char *__s, int __accept1,
>        int __accept2);
>extern __inline size_t
>__strspn_c2 (const char *__s, int __accept1, int __accept2)
>{
>  size_t __result = 0;
>
>  while (__s[__result] == __accept1 || __s[__result] == __accept2)
>    ++__result;
>  return __result;
>}
>
>extern __inline size_t __strspn_c3 (const char *__s, int __accept1,
>        int __accept2, int __accept3);
>extern __inline size_t
>__strspn_c3 (const char *__s, int __accept1, int __accept2, int __accept3)
>{
>  size_t __result = 0;
>
>  while (__s[__result] == __accept1 || __s[__result] == __accept2
>  || __s[__result] == __accept3)
>    ++__result;
>  return __result;
>}
># 1097 "/usr/include/bits/string2.h" 3 4
>extern __inline char *__strpbrk_c2 (const char *__s, int __accept1,
>        int __accept2);
>extern __inline char *
>__strpbrk_c2 (const char *__s, int __accept1, int __accept2)
>{
>
>  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2)
>    ++__s;
>  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
>}
>
>extern __inline char *__strpbrk_c3 (const char *__s, int __accept1,
>        int __accept2, int __accept3);
>extern __inline char *
>__strpbrk_c3 (const char *__s, int __accept1, int __accept2, int __accept3)
>{
>
>  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2
>  && *__s != __accept3)
>    ++__s;
>  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
>}
># 1147 "/usr/include/bits/string2.h" 3 4
>extern __inline char *__strtok_r_1c (char *__s, char __sep, char **__nextp);
>extern __inline char *
>__strtok_r_1c (char *__s, char __sep, char **__nextp)
>{
>  char *__result;
>  if (__s == ((void *)0))
>    __s = *__nextp;
>  while (*__s == __sep)
>    ++__s;
>  __result = ((void *)0);
>  if (*__s != '\0')
>    {
>      __result = __s++;
>      while (*__s != '\0')
> if (*__s++ == __sep)
>   {
>     __s[-1] = '\0';
>     break;
>   }
>    }
>  *__nextp = __s;
>  return __result;
>}
># 1179 "/usr/include/bits/string2.h" 3 4
>extern char *__strsep_g (char **__stringp, const char *__delim);
># 1197 "/usr/include/bits/string2.h" 3 4
>extern __inline char *__strsep_1c (char **__s, char __reject);
>extern __inline char *
>__strsep_1c (char **__s, char __reject)
>{
>  char *__retval = *__s;
>  if (__retval != ((void *)0) && (*__s = (__extension__ (__builtin_constant_p (__reject) && !__builtin_constant_p (__retval) && (__reject) == '\0' ? (char *) __rawmemchr (__retval, __reject) : __builtin_strchr (__retval, __reject)))) != ((void *)0))
>    *(*__s)++ = '\0';
>  return __retval;
>}
>
>extern __inline char *__strsep_2c (char **__s, char __reject1, char __reject2);
>extern __inline char *
>__strsep_2c (char **__s, char __reject1, char __reject2)
>{
>  char *__retval = *__s;
>  if (__retval != ((void *)0))
>    {
>      char *__cp = __retval;
>      while (1)
> {
>   if (*__cp == '\0')
>     {
>       __cp = ((void *)0);
>   break;
>     }
>   if (*__cp == __reject1 || *__cp == __reject2)
>     {
>       *__cp++ = '\0';
>       break;
>     }
>   ++__cp;
> }
>      *__s = __cp;
>    }
>  return __retval;
>}
>
>extern __inline char *__strsep_3c (char **__s, char __reject1, char __reject2,
>       char __reject3);
>extern __inline char *
>__strsep_3c (char **__s, char __reject1, char __reject2, char __reject3)
>{
>  char *__retval = *__s;
>  if (__retval != ((void *)0))
>    {
>      char *__cp = __retval;
>      while (1)
> {
>   if (*__cp == '\0')
>     {
>       __cp = ((void *)0);
>   break;
>     }
>   if (*__cp == __reject1 || *__cp == __reject2 || *__cp == __reject3)
>     {
>       *__cp++ = '\0';
>       break;
>     }
>   ++__cp;
> }
>      *__s = __cp;
>    }
>  return __retval;
>}
># 1278 "/usr/include/bits/string2.h" 3 4
>extern char *__strdup (const char *__string) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__));
># 1297 "/usr/include/bits/string2.h" 3 4
>extern char *__strndup (const char *__string, size_t __n)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__));
># 635 "/usr/include/string.h" 2 3 4
>
>
>
>
># 1 "/usr/include/bits/string3.h" 1 3 4
># 22 "/usr/include/bits/string3.h" 3 4
>extern void __warn_memset_zero_len (void) __attribute__((__warning__ ("memset used with constant zero length parameter; this could be due to transposed parameters")))
>                                                                                                   ;
># 47 "/usr/include/bits/string3.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void *
>__attribute__ ((__nothrow__ , __leaf__)) memcpy (void *__restrict __dest, const void *__restrict __src, size_t __len)
>
>{
>  return __builtin___memcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void *
>__attribute__ ((__nothrow__ , __leaf__)) memmove (void *__dest, const void *__src, size_t __len)
>{
>  return __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void *
>__attribute__ ((__nothrow__ , __leaf__)) mempcpy (void *__restrict __dest, const void *__restrict __src, size_t __len)
>
>{
>  return __builtin___mempcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
>}
># 75 "/usr/include/bits/string3.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void *
>__attribute__ ((__nothrow__ , __leaf__)) memset (void *__dest, int __ch, size_t __len)
>{
>  if (__builtin_constant_p (__len) && __len == 0
>      && (!__builtin_constant_p (__ch) || __ch != 0))
>    {
>      __warn_memset_zero_len ();
>      return __dest;
>    }
>  return __builtin___memset_chk (__dest, __ch, __len, __builtin_object_size (__dest, 0));
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void
>__attribute__ ((__nothrow__ , __leaf__)) bcopy (const void *__src, void *__dest, size_t __len)
>{
>  (void) __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) void
>__attribute__ ((__nothrow__ , __leaf__)) bzero (void *__dest, size_t __len)
>{
>  (void) __builtin___memset_chk (__dest, '\0', __len, __builtin_object_size (__dest, 0));
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) strcpy (char *__restrict __dest, const char *__restrict __src)
>{
>  return __builtin___strcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) stpcpy (char *__restrict __dest, const char *__restrict __src)
>{
>  return __builtin___stpcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
>}
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) strncpy (char *__restrict __dest, const char *__restrict __src, size_t __len)
>
>{
>  return __builtin___strncpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
>}
>
>
>extern char *__stpncpy_chk (char *__dest, const char *__src, size_t __n,
>       size_t __destlen) __attribute__ ((__nothrow__ , __leaf__));
>extern char *__stpncpy_alias (char *__dest, const char *__src, size_t __n) __asm__ ("" "stpncpy") __attribute__ ((__nothrow__ , __leaf__))
>                                 ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) stpncpy (char *__dest, const char *__src, size_t __n)
>{
>  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1
>      && (!__builtin_constant_p (__n) || __n <= __builtin_object_size (__dest, 2 > 1)))
>    return __stpncpy_chk (__dest, __src, __n, __builtin_object_size (__dest, 2 > 1));
>  return __stpncpy_alias (__dest, __src, __n);
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) strcat (char *__restrict __dest, const char *__restrict __src)
>{
>  return __builtin___strcat_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) strncat (char *__restrict __dest, const char *__restrict __src, size_t __len)
>
>{
>  return __builtin___strncat_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
>}
># 640 "/usr/include/string.h" 2 3 4
>
>
>
>
># 55 "hstdinc.h" 2
># 1 "/usr/include/setjmp.h" 1 3 4
># 27 "/usr/include/setjmp.h" 3 4
>
>
># 1 "/usr/include/bits/setjmp.h" 1 3 4
># 26 "/usr/include/bits/setjmp.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 27 "/usr/include/bits/setjmp.h" 2 3 4
># 35 "/usr/include/bits/setjmp.h" 3 4
>typedef int __jmp_buf[6];
># 30 "/usr/include/setjmp.h" 2 3 4
># 1 "/usr/include/bits/sigset.h" 1 3 4
># 31 "/usr/include/setjmp.h" 2 3 4
>
>
>
>struct __jmp_buf_tag
>  {
>
>
>
>
>    __jmp_buf __jmpbuf;
>    int __mask_was_saved;
>    __sigset_t __saved_mask;
>  };
>
>
>
>
>typedef struct __jmp_buf_tag jmp_buf[1];
>
>
>
>extern int setjmp (jmp_buf __env) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern int __sigsetjmp (struct __jmp_buf_tag __env[1], int __savemask) __attribute__ ((__nothrow__));
>
>
>
>extern int _setjmp (struct __jmp_buf_tag __env[1]) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>
>
>
>extern void longjmp (struct __jmp_buf_tag __env[1], int __val)
>     __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));
>
>
>
>
>
>
>
>extern void _longjmp (struct __jmp_buf_tag __env[1], int __val)
>     __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));
>
>
>
>
>
>
>
>typedef struct __jmp_buf_tag sigjmp_buf[1];
># 102 "/usr/include/setjmp.h" 3 4
>extern void siglongjmp (sigjmp_buf __env, int __val)
>     __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));
>
>
>
>
>
># 1 "/usr/include/bits/setjmp2.h" 1 3 4
># 25 "/usr/include/bits/setjmp2.h" 3 4
>extern void longjmp (struct __jmp_buf_tag __env[1], int __val) __asm__ ("" "__longjmp_chk") __attribute__ ((__nothrow__))
>
>                        __attribute__ ((__noreturn__));
>extern void _longjmp (struct __jmp_buf_tag __env[1], int __val) __asm__ ("" "__longjmp_chk") __attribute__ ((__nothrow__))
>
>                        __attribute__ ((__noreturn__));
>extern void siglongjmp (struct __jmp_buf_tag __env[1], int __val) __asm__ ("" "__longjmp_chk") __attribute__ ((__nothrow__))
>
>                        __attribute__ ((__noreturn__));
># 110 "/usr/include/setjmp.h" 2 3 4
>
>
>
># 56 "hstdinc.h" 2
># 1 "/usr/include/ctype.h" 1 3 4
># 28 "/usr/include/ctype.h" 3 4
>
># 46 "/usr/include/ctype.h" 3 4
>enum
>{
>  _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
>  _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
>  _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
>  _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
>  _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
>  _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
>  _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
>  _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
>  _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
>  _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
>  _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
>  _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
>};
># 79 "/usr/include/ctype.h" 3 4
>extern const unsigned short int **__ctype_b_loc (void)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>extern const __int32_t **__ctype_tolower_loc (void)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>extern const __int32_t **__ctype_toupper_loc (void)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
># 104 "/usr/include/ctype.h" 3 4
>
>
>
>
>
>
>extern int isalnum (int) __attribute__ ((__nothrow__ , __leaf__));
>extern int isalpha (int) __attribute__ ((__nothrow__ , __leaf__));
>extern int iscntrl (int) __attribute__ ((__nothrow__ , __leaf__));
>extern int isdigit (int) __attribute__ ((__nothrow__ , __leaf__));
>extern int islower (int) __attribute__ ((__nothrow__ , __leaf__));
>extern int isgraph (int) __attribute__ ((__nothrow__ , __leaf__));
>extern int isprint (int) __attribute__ ((__nothrow__ , __leaf__));
>extern int ispunct (int) __attribute__ ((__nothrow__ , __leaf__));
>extern int isspace (int) __attribute__ ((__nothrow__ , __leaf__));
>extern int isupper (int) __attribute__ ((__nothrow__ , __leaf__));
>extern int isxdigit (int) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int tolower (int __c) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int toupper (int __c) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern int isblank (int) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int isctype (int __c, int __mask) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int isascii (int __c) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int toascii (int __c) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int _toupper (int) __attribute__ ((__nothrow__ , __leaf__));
>extern int _tolower (int) __attribute__ ((__nothrow__ , __leaf__));
># 214 "/usr/include/ctype.h" 3 4
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) tolower (int __c)
>{
>  return __c >= -128 && __c < 256 ? (*__ctype_tolower_loc ())[__c] : __c;
>}
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) toupper (int __c)
>{
>  return __c >= -128 && __c < 256 ? (*__ctype_toupper_loc ())[__c] : __c;
>}
># 271 "/usr/include/ctype.h" 3 4
>extern int isalnum_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>extern int isalpha_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>extern int iscntrl_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>extern int isdigit_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>extern int islower_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>extern int isgraph_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>extern int isprint_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>extern int ispunct_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>extern int isspace_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>extern int isupper_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>extern int isxdigit_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>
>extern int isblank_l (int, __locale_t) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int __tolower_l (int __c, __locale_t __l) __attribute__ ((__nothrow__ , __leaf__));
>extern int tolower_l (int __c, __locale_t __l) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int __toupper_l (int __c, __locale_t __l) __attribute__ ((__nothrow__ , __leaf__));
>extern int toupper_l (int __c, __locale_t __l) __attribute__ ((__nothrow__ , __leaf__));
># 347 "/usr/include/ctype.h" 3 4
>
># 57 "hstdinc.h" 2
># 1 "/usr/include/errno.h" 1 3 4
># 31 "/usr/include/errno.h" 3 4
>
>
>
>
># 1 "/usr/include/bits/errno.h" 1 3 4
># 24 "/usr/include/bits/errno.h" 3 4
># 1 "/usr/include/linux/errno.h" 1 3 4
># 1 "/usr/include/asm/errno.h" 1 3 4
># 1 "/usr/include/asm-generic/errno.h" 1 3 4
>
>
>
># 1 "/usr/include/asm-generic/errno-base.h" 1 3 4
># 5 "/usr/include/asm-generic/errno.h" 2 3 4
># 1 "/usr/include/asm/errno.h" 2 3 4
># 1 "/usr/include/linux/errno.h" 2 3 4
># 25 "/usr/include/bits/errno.h" 2 3 4
># 50 "/usr/include/bits/errno.h" 3 4
>extern int *__errno_location (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
># 36 "/usr/include/errno.h" 2 3 4
># 54 "/usr/include/errno.h" 3 4
>extern char *program_invocation_name, *program_invocation_short_name;
>
>
>
>
># 68 "/usr/include/errno.h" 3 4
>typedef int error_t;
># 58 "hstdinc.h" 2
># 1 "/usr/include/fcntl.h" 1 3 4
># 28 "/usr/include/fcntl.h" 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/bits/fcntl.h" 1 3 4
># 35 "/usr/include/bits/fcntl.h" 3 4
>struct flock
>  {
>    short int l_type;
>    short int l_whence;
>
>
>
>
>    __off64_t l_start;
>    __off64_t l_len;
>
>    __pid_t l_pid;
>  };
>
>
>struct flock64
>  {
>    short int l_type;
>    short int l_whence;
>    __off64_t l_start;
>    __off64_t l_len;
>    __pid_t l_pid;
>  };
>
>
>
># 1 "/usr/include/bits/fcntl-linux.h" 1 3 4
># 38 "/usr/include/bits/fcntl-linux.h" 3 4
># 1 "/usr/include/bits/uio.h" 1 3 4
># 43 "/usr/include/bits/uio.h" 3 4
>struct iovec
>  {
>    void *iov_base;
>    size_t iov_len;
>  };
># 39 "/usr/include/bits/fcntl-linux.h" 2 3 4
># 258 "/usr/include/bits/fcntl-linux.h" 3 4
>enum __pid_type
>  {
>    F_OWNER_TID = 0,
>    F_OWNER_PID,
>    F_OWNER_PGRP,
>    F_OWNER_GID = F_OWNER_PGRP
>  };
>
>
>struct f_owner_ex
>  {
>    enum __pid_type type;
>    __pid_t pid;
>  };
># 333 "/usr/include/bits/fcntl-linux.h" 3 4
>struct file_handle
>{
>  unsigned int handle_bytes;
>  int handle_type;
>
>  unsigned char f_handle[0];
>};
>
>
>
>
>
>
>
>
>
>
>extern ssize_t readahead (int __fd, __off64_t __offset, size_t __count)
>    __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int sync_file_range (int __fd, __off64_t __offset, __off64_t __count,
>       unsigned int __flags);
>
>
>
>
>
>
>extern ssize_t vmsplice (int __fdout, const struct iovec *__iov,
>    size_t __count, unsigned int __flags);
>
>
>
>
>
>extern ssize_t splice (int __fdin, __off64_t *__offin, int __fdout,
>         __off64_t *__offout, size_t __len,
>         unsigned int __flags);
>
>
>
>
>
>extern ssize_t tee (int __fdin, int __fdout, size_t __len,
>      unsigned int __flags);
># 392 "/usr/include/bits/fcntl-linux.h" 3 4
>extern int fallocate (int __fd, int __mode, __off64_t __offset, __off64_t __len) __asm__ ("" "fallocate64")
>
>                     ;
>
>
>
>
>
>extern int fallocate64 (int __fd, int __mode, __off64_t __offset,
>   __off64_t __len);
>
>
>
>
>extern int name_to_handle_at (int __dfd, const char *__name,
>         struct file_handle *__handle, int *__mnt_id,
>         int __flags) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int open_by_handle_at (int __mountdirfd, struct file_handle *__handle,
>         int __flags);
>
>
>
>
># 61 "/usr/include/bits/fcntl.h" 2 3 4
># 36 "/usr/include/fcntl.h" 2 3 4
># 67 "/usr/include/fcntl.h" 3 4
># 1 "/usr/include/time.h" 1 3 4
># 68 "/usr/include/fcntl.h" 2 3 4
># 1 "/usr/include/bits/stat.h" 1 3 4
># 46 "/usr/include/bits/stat.h" 3 4
>struct stat
>  {
>    __dev_t st_dev;
>
>    unsigned short int __pad1;
>
>
>
>
>    __ino_t __st_ino;
>
>
>    __mode_t st_mode;
>    __nlink_t st_nlink;
>
>
>
>
>    __uid_t st_uid;
>    __gid_t st_gid;
>
>
>
>    __dev_t st_rdev;
>
>    unsigned short int __pad2;
>
>
>
>
>    __off64_t st_size;
>
>    __blksize_t st_blksize;
>
>
>
>    __blkcnt64_t st_blocks;
># 91 "/usr/include/bits/stat.h" 3 4
>    struct timespec st_atim;
>    struct timespec st_mtim;
>    struct timespec st_ctim;
># 112 "/usr/include/bits/stat.h" 3 4
>    __ino64_t st_ino;
>
>
>  };
>
>
>
>struct stat64
>  {
>    __dev_t st_dev;
>
>
>
>
>
>    unsigned int __pad1;
>    __ino_t __st_ino;
>    __mode_t st_mode;
>    __nlink_t st_nlink;
>
>    __uid_t st_uid;
>    __gid_t st_gid;
>
>
>
>
>
>    __dev_t st_rdev;
>    unsigned int __pad2;
>    __off64_t st_size;
>
>    __blksize_t st_blksize;
>    __blkcnt64_t st_blocks;
>
>
>
>
>
>
>
>    struct timespec st_atim;
>    struct timespec st_mtim;
>    struct timespec st_ctim;
># 166 "/usr/include/bits/stat.h" 3 4
>    __ino64_t st_ino;
>
>  };
># 69 "/usr/include/fcntl.h" 2 3 4
># 160 "/usr/include/fcntl.h" 3 4
>extern int fcntl (int __fd, int __cmd, ...);
># 172 "/usr/include/fcntl.h" 3 4
>extern int open (const char *__file, int __oflag, ...) __asm__ ("" "open64")
>     __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int open64 (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
># 197 "/usr/include/fcntl.h" 3 4
>extern int openat (int __fd, const char *__file, int __oflag, ...) __asm__ ("" "openat64")
>                    __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>extern int openat64 (int __fd, const char *__file, int __oflag, ...)
>     __attribute__ ((__nonnull__ (2)));
># 218 "/usr/include/fcntl.h" 3 4
>extern int creat (const char *__file, mode_t __mode) __asm__ ("" "creat64")
>                  __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int creat64 (const char *__file, mode_t __mode) __attribute__ ((__nonnull__ (1)));
># 247 "/usr/include/fcntl.h" 3 4
>extern int lockf (int __fd, int __cmd, __off64_t __len) __asm__ ("" "lockf64");
>
>
>
>
>
>extern int lockf64 (int __fd, int __cmd, off64_t __len);
># 265 "/usr/include/fcntl.h" 3 4
>extern int posix_fadvise (int __fd, __off64_t __offset, __off64_t __len, int __advise) __asm__ ("" "posix_fadvise64") __attribute__ ((__nothrow__ , __leaf__))
>
>                      ;
>
>
>
>
>
>extern int posix_fadvise64 (int __fd, off64_t __offset, off64_t __len,
>       int __advise) __attribute__ ((__nothrow__ , __leaf__));
># 286 "/usr/include/fcntl.h" 3 4
>extern int posix_fallocate (int __fd, __off64_t __offset, __off64_t __len) __asm__ ("" "posix_fallocate64")
>
>                           ;
>
>
>
>
>
>extern int posix_fallocate64 (int __fd, off64_t __offset, off64_t __len);
>
>
>
>
>
>
>
># 1 "/usr/include/bits/fcntl2.h" 1 3 4
># 30 "/usr/include/bits/fcntl2.h" 3 4
>extern int __open_2 (const char *__path, int __oflag) __asm__ ("" "__open64_2")
>                     __attribute__ ((__nonnull__ (1)));
>extern int __open_alias (const char *__path, int __oflag, ...) __asm__ ("" "open64")
>                 __attribute__ ((__nonnull__ (1)));
>
>extern void __open_too_many_args (void) __attribute__((__error__ ("open can be called either with 2 or 3 arguments, not more")))
>                                                                  ;
>extern void __open_missing_mode (void) __attribute__((__error__ ("open with O_CREAT in second argument needs 3 arguments")))
>                                                               ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>open (const char *__path, int __oflag, ...)
>{
>  if (__builtin_va_arg_pack_len () > 1)
>    __open_too_many_args ();
>
>  if (__builtin_constant_p (__oflag))
>    {
>      if ((__oflag & 0100) != 0 && __builtin_va_arg_pack_len () < 1)
> {
>   __open_missing_mode ();
>   return __open_2 (__path, __oflag);
> }
>      return __open_alias (__path, __oflag, __builtin_va_arg_pack ());
>    }
>
>  if (__builtin_va_arg_pack_len () < 1)
>    return __open_2 (__path, __oflag);
>
>  return __open_alias (__path, __oflag, __builtin_va_arg_pack ());
>}
>
>
>
>extern int __open64_2 (const char *__path, int __oflag) __attribute__ ((__nonnull__ (1)));
>extern int __open64_alias (const char *__path, int __oflag, ...) __asm__ ("" "open64")
>                   __attribute__ ((__nonnull__ (1)));
>extern void __open64_too_many_args (void) __attribute__((__error__ ("open64 can be called either with 2 or 3 arguments, not more")))
>                                                                    ;
>extern void __open64_missing_mode (void) __attribute__((__error__ ("open64 with O_CREAT in second argument needs 3 arguments")))
>                                                                 ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>open64 (const char *__path, int __oflag, ...)
>{
>  if (__builtin_va_arg_pack_len () > 1)
>    __open64_too_many_args ();
>
>  if (__builtin_constant_p (__oflag))
>    {
>      if ((__oflag & 0100) != 0 && __builtin_va_arg_pack_len () < 1)
> {
>   __open64_missing_mode ();
>   return __open64_2 (__path, __oflag);
> }
>      return __open64_alias (__path, __oflag, __builtin_va_arg_pack ());
>    }
>
>  if (__builtin_va_arg_pack_len () < 1)
>    return __open64_2 (__path, __oflag);
>
>  return __open64_alias (__path, __oflag, __builtin_va_arg_pack ());
>}
># 104 "/usr/include/bits/fcntl2.h" 3 4
>extern int __openat_2 (int __fd, const char *__path, int __oflag) __asm__ ("" "__openat64_2")
>
>     __attribute__ ((__nonnull__ (2)));
>extern int __openat_alias (int __fd, const char *__path, int __oflag, ...) __asm__ ("" "openat64")
>
>     __attribute__ ((__nonnull__ (2)));
>
>extern void __openat_too_many_args (void) __attribute__((__error__ ("openat can be called either with 3 or 4 arguments, not more")))
>                                                                    ;
>extern void __openat_missing_mode (void) __attribute__((__error__ ("openat with O_CREAT in third argument needs 4 arguments")))
>                                                                ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>openat (int __fd, const char *__path, int __oflag, ...)
>{
>  if (__builtin_va_arg_pack_len () > 1)
>    __openat_too_many_args ();
>
>  if (__builtin_constant_p (__oflag))
>    {
>      if ((__oflag & 0100) != 0 && __builtin_va_arg_pack_len () < 1)
> {
>   __openat_missing_mode ();
>   return __openat_2 (__fd, __path, __oflag);
> }
>      return __openat_alias (__fd, __path, __oflag, __builtin_va_arg_pack ());
>    }
>
>  if (__builtin_va_arg_pack_len () < 1)
>    return __openat_2 (__fd, __path, __oflag);
>
>  return __openat_alias (__fd, __path, __oflag, __builtin_va_arg_pack ());
>}
>
>
>
>extern int __openat64_2 (int __fd, const char *__path, int __oflag)
>     __attribute__ ((__nonnull__ (2)));
>extern int __openat64_alias (int __fd, const char *__path, int __oflag, ...) __asm__ ("" "openat64")
>
>     __attribute__ ((__nonnull__ (2)));
>extern void __openat64_too_many_args (void) __attribute__((__error__ ("openat64 can be called either with 3 or 4 arguments, not more")))
>                                                                      ;
>extern void __openat64_missing_mode (void) __attribute__((__error__ ("openat64 with O_CREAT in third argument needs 4 arguments")))
>                                                                  ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>openat64 (int __fd, const char *__path, int __oflag, ...)
>{
>  if (__builtin_va_arg_pack_len () > 1)
>    __openat64_too_many_args ();
>
>  if (__builtin_constant_p (__oflag))
>    {
>      if ((__oflag & 0100) != 0 && __builtin_va_arg_pack_len () < 1)
> {
>   __openat64_missing_mode ();
>   return __openat64_2 (__fd, __path, __oflag);
> }
>      return __openat64_alias (__fd, __path, __oflag, __builtin_va_arg_pack ());
>    }
>
>  if (__builtin_va_arg_pack_len () < 1)
>    return __openat64_2 (__fd, __path, __oflag);
>
>  return __openat64_alias (__fd, __path, __oflag, __builtin_va_arg_pack ());
>}
># 303 "/usr/include/fcntl.h" 2 3 4
>
>
>
># 59 "hstdinc.h" 2
>
>
>
>
>
>
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/limits.h" 1 3 4
># 34 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/limits.h" 3 4
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/syslimits.h" 1 3 4
>
>
>
>
>
>
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/limits.h" 1 3 4
># 168 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/limits.h" 3 4
># 1 "/usr/include/limits.h" 1 3 4
># 143 "/usr/include/limits.h" 3 4
># 1 "/usr/include/bits/posix1_lim.h" 1 3 4
># 160 "/usr/include/bits/posix1_lim.h" 3 4
># 1 "/usr/include/bits/local_lim.h" 1 3 4
># 38 "/usr/include/bits/local_lim.h" 3 4
># 1 "/usr/include/linux/limits.h" 1 3 4
># 39 "/usr/include/bits/local_lim.h" 2 3 4
># 161 "/usr/include/bits/posix1_lim.h" 2 3 4
># 144 "/usr/include/limits.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/posix2_lim.h" 1 3 4
># 148 "/usr/include/limits.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/xopen_lim.h" 1 3 4
># 33 "/usr/include/bits/xopen_lim.h" 3 4
># 1 "/usr/include/bits/stdio_lim.h" 1 3 4
># 34 "/usr/include/bits/xopen_lim.h" 2 3 4
># 152 "/usr/include/limits.h" 2 3 4
># 169 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/limits.h" 2 3 4
># 8 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/syslimits.h" 2 3 4
># 35 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/limits.h" 2 3 4
># 66 "hstdinc.h" 2
># 1 "/usr/include/time.h" 1 3 4
># 29 "/usr/include/time.h" 3 4
>
>
>
>
>
>
>
>
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 38 "/usr/include/time.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/time.h" 1 3 4
># 86 "/usr/include/bits/time.h" 3 4
># 1 "/usr/include/bits/timex.h" 1 3 4
># 25 "/usr/include/bits/timex.h" 3 4
>struct timex
>{
>  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;
>};
># 87 "/usr/include/bits/time.h" 2 3 4
>
>
>
>
>extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) __attribute__ ((__nothrow__ , __leaf__));
>
>
># 42 "/usr/include/time.h" 2 3 4
># 131 "/usr/include/time.h" 3 4
>
>
>struct tm
>{
>  int tm_sec;
>  int tm_min;
>  int tm_hour;
>  int tm_mday;
>  int tm_mon;
>  int tm_year;
>  int tm_wday;
>  int tm_yday;
>  int tm_isdst;
>
>
>  long int tm_gmtoff;
>  const char *tm_zone;
>
>
>
>
>};
>
>
>
>
>
>
>
>
>struct itimerspec
>  {
>    struct timespec it_interval;
>    struct timespec it_value;
>  };
>
>
>struct sigevent;
># 186 "/usr/include/time.h" 3 4
>
>
>
>extern clock_t clock (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern time_t time (time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double difftime (time_t __time1, time_t __time0)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern time_t mktime (struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern size_t strftime (char *__restrict __s, size_t __maxsize,
>   const char *__restrict __format,
>   const struct tm *__restrict __tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern char *strptime (const char *__restrict __s,
>         const char *__restrict __fmt, struct tm *__tp)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>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__ , __leaf__));
>
>
>
>extern char *strptime_l (const char *__restrict __s,
>    const char *__restrict __fmt, struct tm *__tp,
>    __locale_t __loc) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern struct tm *gmtime (const time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern struct tm *localtime (const time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern struct tm *gmtime_r (const time_t *__restrict __timer,
>       struct tm *__restrict __tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern struct tm *localtime_r (const time_t *__restrict __timer,
>          struct tm *__restrict __tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern char *asctime (const struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern char *ctime (const time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern char *asctime_r (const struct tm *__restrict __tp,
>   char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern char *ctime_r (const time_t *__restrict __timer,
>        char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern char *__tzname[2];
>extern int __daylight;
>extern long int __timezone;
>
>
>
>
>extern char *tzname[2];
>
>
>
>extern void tzset (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int daylight;
>extern long int timezone;
>
>
>
>
>
>extern int stime (const time_t *__when) __attribute__ ((__nothrow__ , __leaf__));
># 319 "/usr/include/time.h" 3 4
>extern time_t timegm (struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern time_t timelocal (struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int dysize (int __year) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
># 334 "/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__ , __leaf__));
>
>
>extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int clock_nanosleep (clockid_t __clock_id, int __flags,
>       const struct timespec *__req,
>       struct timespec *__rem);
>
>
>extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int timer_create (clockid_t __clock_id,
>    struct sigevent *__restrict __evp,
>    timer_t *__restrict __timerid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int timer_delete (timer_t __timerid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int timer_settime (timer_t __timerid, int __flags,
>     const struct itimerspec *__restrict __value,
>     struct itimerspec *__restrict __ovalue) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int timer_getoverrun (timer_t __timerid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int timespec_get (struct timespec *__ts, int __base)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 403 "/usr/include/time.h" 3 4
>extern int getdate_err;
># 412 "/usr/include/time.h" 3 4
>extern struct tm *getdate (const char *__string);
># 426 "/usr/include/time.h" 3 4
>extern int getdate_r (const char *__restrict __string,
>        struct tm *__restrict __resbufp);
>
>
>
># 67 "hstdinc.h" 2
># 1 "/usr/include/sys/stat.h" 1 3 4
># 102 "/usr/include/sys/stat.h" 3 4
>
>
># 1 "/usr/include/bits/stat.h" 1 3 4
># 105 "/usr/include/sys/stat.h" 2 3 4
># 216 "/usr/include/sys/stat.h" 3 4
>extern int stat (const char *__restrict __file, struct stat *__restrict __buf) __asm__ ("" "stat64") __attribute__ ((__nothrow__ , __leaf__))
>
>     __attribute__ ((__nonnull__ (1, 2)));
>extern int fstat (int __fd, struct stat *__buf) __asm__ ("" "fstat64") __attribute__ ((__nothrow__ , __leaf__))
>     __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>
>extern int stat64 (const char *__restrict __file,
>     struct stat64 *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>extern int fstat64 (int __fd, struct stat64 *__buf) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
># 242 "/usr/include/sys/stat.h" 3 4
>extern int fstatat (int __fd, const char *__restrict __file, struct stat *__restrict __buf, int __flag) __asm__ ("" "fstatat64") __attribute__ ((__nothrow__ , __leaf__))
>
>
>                 __attribute__ ((__nonnull__ (2, 3)));
>
>
>
>
>
>
>extern int fstatat64 (int __fd, const char *__restrict __file,
>        struct stat64 *__restrict __buf, int __flag)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3)));
># 266 "/usr/include/sys/stat.h" 3 4
>extern int lstat (const char *__restrict __file, struct stat *__restrict __buf) __asm__ ("" "lstat64") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int lstat64 (const char *__restrict __file,
>      struct stat64 *__restrict __buf)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int chmod (const char *__file, __mode_t __mode)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int lchmod (const char *__file, __mode_t __mode)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int fchmod (int __fd, __mode_t __mode) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int fchmodat (int __fd, const char *__file, __mode_t __mode,
>       int __flag)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern __mode_t umask (__mode_t __mask) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern __mode_t getumask (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int mkdir (const char *__path, __mode_t __mode)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int mkdirat (int __fd, const char *__path, __mode_t __mode)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>
>extern int mknod (const char *__path, __mode_t __mode, __dev_t __dev)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int mknodat (int __fd, const char *__path, __mode_t __mode,
>      __dev_t __dev) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>extern int mkfifo (const char *__path, __mode_t __mode)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int mkfifoat (int __fd, const char *__path, __mode_t __mode)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>extern int utimensat (int __fd, const char *__path,
>        const struct timespec __times[2],
>        int __flags)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern int futimens (int __fd, const struct timespec __times[2]) __attribute__ ((__nothrow__ , __leaf__));
># 409 "/usr/include/sys/stat.h" 3 4
>extern int __fxstat (int __ver, int __fildes, struct stat *__stat_buf) __asm__ ("" "__fxstat64") __attribute__ ((__nothrow__ , __leaf__))
>
>     __attribute__ ((__nonnull__ (3)));
>extern int __xstat (int __ver, const char *__filename, struct stat *__stat_buf) __asm__ ("" "__xstat64") __attribute__ ((__nothrow__ , __leaf__))
>
>     __attribute__ ((__nonnull__ (2, 3)));
>extern int __lxstat (int __ver, const char *__filename, struct stat *__stat_buf) __asm__ ("" "__lxstat64") __attribute__ ((__nothrow__ , __leaf__))
>
>     __attribute__ ((__nonnull__ (2, 3)));
>extern int __fxstatat (int __ver, int __fildes, const char *__filename, struct stat *__stat_buf, int __flag) __asm__ ("" "__fxstatat64") __attribute__ ((__nothrow__ , __leaf__))
>
>
>                    __attribute__ ((__nonnull__ (3, 4)));
># 431 "/usr/include/sys/stat.h" 3 4
>extern int __fxstat64 (int __ver, int __fildes, struct stat64 *__stat_buf)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3)));
>extern int __xstat64 (int __ver, const char *__filename,
>        struct stat64 *__stat_buf) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3)));
>extern int __lxstat64 (int __ver, const char *__filename,
>         struct stat64 *__stat_buf) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3)));
>extern int __fxstatat64 (int __ver, int __fildes, const char *__filename,
>    struct stat64 *__stat_buf, int __flag)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4)));
>
>extern int __xmknod (int __ver, const char *__path, __mode_t __mode,
>       __dev_t *__dev) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 4)));
>
>extern int __xmknodat (int __ver, int __fd, const char *__path,
>         __mode_t __mode, __dev_t *__dev)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 5)));
>
>
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) stat (const char *__path, struct stat *__statbuf)
>{
>  return __xstat (3, __path, __statbuf);
>}
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) lstat (const char *__path, struct stat *__statbuf)
>{
>  return __lxstat (3, __path, __statbuf);
>}
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) fstat (int __fd, struct stat *__statbuf)
>{
>  return __fxstat (3, __fd, __statbuf);
>}
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) fstatat (int __fd, const char *__filename, struct stat *__statbuf, int __flag)
>
>{
>  return __fxstatat (3, __fd, __filename, __statbuf, __flag);
>}
>
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) mknod (const char *__path, __mode_t __mode, __dev_t __dev)
>{
>  return __xmknod (1, __path, __mode, &__dev);
>}
>
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) mknodat (int __fd, const char *__path, __mode_t __mode, __dev_t __dev)
>
>{
>  return __xmknodat (1, __fd, __path, __mode, &__dev);
>}
>
>
>
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) stat64 (const char *__path, struct stat64 *__statbuf)
>{
>  return __xstat64 (3, __path, __statbuf);
>}
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) lstat64 (const char *__path, struct stat64 *__statbuf)
>{
>  return __lxstat64 (3, __path, __statbuf);
>}
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) fstat64 (int __fd, struct stat64 *__statbuf)
>{
>  return __fxstat64 (3, __fd, __statbuf);
>}
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) fstatat64 (int __fd, const char *__filename, struct stat64 *__statbuf, int __flag)
>
>{
>  return __fxstatat64 (3, __fd, __filename, __statbuf, __flag);
>}
>
>
>
>
>
>
>
># 68 "hstdinc.h" 2
>
># 1 "/usr/include/sys/time.h" 1 3 4
># 27 "/usr/include/sys/time.h" 3 4
># 1 "/usr/include/bits/time.h" 1 3 4
># 28 "/usr/include/sys/time.h" 2 3 4
># 37 "/usr/include/sys/time.h" 3 4
>
># 55 "/usr/include/sys/time.h" 3 4
>struct timezone
>  {
>    int tz_minuteswest;
>    int tz_dsttime;
>  };
>
>typedef struct timezone *__restrict __timezone_ptr_t;
># 71 "/usr/include/sys/time.h" 3 4
>extern int gettimeofday (struct timeval *__restrict __tv,
>    __timezone_ptr_t __tz) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int settimeofday (const struct timeval *__tv,
>    const struct timezone *__tz)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int adjtime (const struct timeval *__delta,
>      struct timeval *__olddelta) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>enum __itimer_which
>  {
>
>    ITIMER_REAL = 0,
>
>
>    ITIMER_VIRTUAL = 1,
>
>
>
>    ITIMER_PROF = 2
>
>  };
>
>
>
>struct itimerval
>  {
>
>    struct timeval it_interval;
>
>    struct timeval it_value;
>  };
>
>
>
>
>typedef enum __itimer_which __itimer_which_t;
>
>
>
>
>
>
>extern int getitimer (__itimer_which_t __which,
>        struct itimerval *__value) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int setitimer (__itimer_which_t __which,
>        const struct itimerval *__restrict __new,
>        struct itimerval *__restrict __old) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int utimes (const char *__file, const struct timeval __tvp[2])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int lutimes (const char *__file, const struct timeval __tvp[2])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int futimes (int __fd, const struct timeval __tvp[2]) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int futimesat (int __fd, const char *__file,
>        const struct timeval __tvp[2]) __attribute__ ((__nothrow__ , __leaf__));
># 189 "/usr/include/sys/time.h" 3 4
>
># 70 "hstdinc.h" 2
># 1 "/usr/include/sys/ioctl.h" 1 3 4
># 23 "/usr/include/sys/ioctl.h" 3 4
>
>
>
># 1 "/usr/include/bits/ioctls.h" 1 3 4
># 23 "/usr/include/bits/ioctls.h" 3 4
># 1 "/usr/include/asm/ioctls.h" 1 3 4
># 1 "/usr/include/asm-generic/ioctls.h" 1 3 4
>
>
>
># 1 "/usr/include/linux/ioctl.h" 1 3 4
>
>
>
># 1 "/usr/include/asm/ioctl.h" 1 3 4
># 1 "/usr/include/asm-generic/ioctl.h" 1 3 4
># 1 "/usr/include/asm/ioctl.h" 2 3 4
># 5 "/usr/include/linux/ioctl.h" 2 3 4
># 5 "/usr/include/asm-generic/ioctls.h" 2 3 4
># 1 "/usr/include/asm/ioctls.h" 2 3 4
># 24 "/usr/include/bits/ioctls.h" 2 3 4
># 27 "/usr/include/sys/ioctl.h" 2 3 4
>
>
># 1 "/usr/include/bits/ioctl-types.h" 1 3 4
># 24 "/usr/include/bits/ioctl-types.h" 3 4
># 1 "/usr/include/asm/ioctls.h" 1 3 4
># 25 "/usr/include/bits/ioctl-types.h" 2 3 4
>
>
>struct winsize
>  {
>    unsigned short int ws_row;
>    unsigned short int ws_col;
>    unsigned short int ws_xpixel;
>    unsigned short int ws_ypixel;
>  };
>
>
>struct termio
>  {
>    unsigned short int c_iflag;
>    unsigned short int c_oflag;
>    unsigned short int c_cflag;
>    unsigned short int c_lflag;
>    unsigned char c_line;
>    unsigned char c_cc[8];
>};
># 30 "/usr/include/sys/ioctl.h" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/sys/ttydefaults.h" 1 3 4
># 37 "/usr/include/sys/ioctl.h" 2 3 4
>
>
>
>
>extern int ioctl (int __fd, unsigned long int __request, ...) __attribute__ ((__nothrow__ , __leaf__));
>
>
># 71 "hstdinc.h" 2
># 80 "hstdinc.h"
># 1 "/usr/include/sys/socket.h" 1 3 4
># 24 "/usr/include/sys/socket.h" 3 4
>
>
># 1 "/usr/include/sys/uio.h" 1 3 4
># 25 "/usr/include/sys/uio.h" 3 4
>
>
>
># 1 "/usr/include/bits/uio.h" 1 3 4
># 56 "/usr/include/bits/uio.h" 3 4
>
>
>
>extern ssize_t process_vm_readv (pid_t __pid, const struct iovec *__lvec,
>     unsigned long int __liovcnt,
>     const struct iovec *__rvec,
>     unsigned long int __riovcnt,
>     unsigned long int __flags)
>  __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern ssize_t process_vm_writev (pid_t __pid, const struct iovec *__lvec,
>      unsigned long int __liovcnt,
>      const struct iovec *__rvec,
>      unsigned long int __riovcnt,
>      unsigned long int __flags)
>  __attribute__ ((__nothrow__ , __leaf__));
>
>
># 29 "/usr/include/sys/uio.h" 2 3 4
># 39 "/usr/include/sys/uio.h" 3 4
>extern ssize_t readv (int __fd, const struct iovec *__iovec, int __count)
>  __attribute__ ((__warn_unused_result__));
># 50 "/usr/include/sys/uio.h" 3 4
>extern ssize_t writev (int __fd, const struct iovec *__iovec, int __count)
>  __attribute__ ((__warn_unused_result__));
># 81 "/usr/include/sys/uio.h" 3 4
>extern ssize_t preadv (int __fd, const struct iovec *__iovec, int __count, __off64_t __offset) __asm__ ("" "preadv64")
>
>                __attribute__ ((__warn_unused_result__));
>extern ssize_t pwritev (int __fd, const struct iovec *__iovec, int __count, __off64_t __offset) __asm__ ("" "pwritev64")
>
>                 __attribute__ ((__warn_unused_result__));
># 103 "/usr/include/sys/uio.h" 3 4
>extern ssize_t preadv64 (int __fd, const struct iovec *__iovec, int __count,
>    __off64_t __offset) __attribute__ ((__warn_unused_result__));
># 115 "/usr/include/sys/uio.h" 3 4
>extern ssize_t pwritev64 (int __fd, const struct iovec *__iovec, int __count,
>     __off64_t __offset) __attribute__ ((__warn_unused_result__));
>
>
>
>
># 27 "/usr/include/sys/socket.h" 2 3 4
>
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 29 "/usr/include/sys/socket.h" 2 3 4
>
>
># 1 "/usr/include/bits/sigset.h" 1 3 4
># 32 "/usr/include/sys/socket.h" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/bits/socket.h" 1 3 4
># 27 "/usr/include/bits/socket.h" 3 4
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 28 "/usr/include/bits/socket.h" 2 3 4
>
>
>
>
>
>typedef __socklen_t socklen_t;
>
>
>
>
># 1 "/usr/include/bits/socket_type.h" 1 3 4
># 24 "/usr/include/bits/socket_type.h" 3 4
>enum __socket_type
>{
>  SOCK_STREAM = 1,
>
>
>  SOCK_DGRAM = 2,
>
>
>  SOCK_RAW = 3,
>
>  SOCK_RDM = 4,
>
>  SOCK_SEQPACKET = 5,
>
>
>  SOCK_DCCP = 6,
>
>  SOCK_PACKET = 10,
>
>
>
>
>
>
>
>  SOCK_CLOEXEC = 02000000,
>
>
>  SOCK_NONBLOCK = 00004000
>
>
>};
># 39 "/usr/include/bits/socket.h" 2 3 4
># 146 "/usr/include/bits/socket.h" 3 4
># 1 "/usr/include/bits/sockaddr.h" 1 3 4
># 28 "/usr/include/bits/sockaddr.h" 3 4
>typedef unsigned short int sa_family_t;
># 147 "/usr/include/bits/socket.h" 2 3 4
>
>
>struct sockaddr
>  {
>    sa_family_t sa_family;
>    char sa_data[14];
>  };
># 162 "/usr/include/bits/socket.h" 3 4
>struct sockaddr_storage
>  {
>    sa_family_t ss_family;
>    unsigned long int __ss_align;
>    char __ss_padding[(128 - (2 * sizeof (unsigned long int)))];
>  };
>
>
>
>enum
>  {
>    MSG_OOB = 0x01,
>
>    MSG_PEEK = 0x02,
>
>    MSG_DONTROUTE = 0x04,
>
>
>
>    MSG_TRYHARD = MSG_DONTROUTE,
>
>
>    MSG_CTRUNC = 0x08,
>
>    MSG_PROXY = 0x10,
>
>    MSG_TRUNC = 0x20,
>
>    MSG_DONTWAIT = 0x40,
>
>    MSG_EOR = 0x80,
>
>    MSG_WAITALL = 0x100,
>
>    MSG_FIN = 0x200,
>
>    MSG_SYN = 0x400,
>
>    MSG_CONFIRM = 0x800,
>
>    MSG_RST = 0x1000,
>
>    MSG_ERRQUEUE = 0x2000,
>
>    MSG_NOSIGNAL = 0x4000,
>
>    MSG_MORE = 0x8000,
>
>    MSG_WAITFORONE = 0x10000,
>
>    MSG_FASTOPEN = 0x20000000,
>
>
>    MSG_CMSG_CLOEXEC = 0x40000000
>
>
>
>  };
>
>
>
>
>struct msghdr
>  {
>    void *msg_name;
>    socklen_t msg_namelen;
>
>    struct iovec *msg_iov;
>    size_t msg_iovlen;
>
>    void *msg_control;
>    size_t msg_controllen;
>
>
>
>
>    int msg_flags;
>  };
>
>
>struct cmsghdr
>  {
>    size_t cmsg_len;
>
>
>
>
>    int cmsg_level;
>    int cmsg_type;
>
>    __extension__ unsigned char __cmsg_data [];
>
>  };
># 272 "/usr/include/bits/socket.h" 3 4
>extern struct cmsghdr *__cmsg_nxthdr (struct msghdr *__mhdr,
>          struct cmsghdr *__cmsg) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern __inline struct cmsghdr *
>__attribute__ ((__nothrow__ , __leaf__)) __cmsg_nxthdr (struct msghdr *__mhdr, struct cmsghdr *__cmsg)
>{
>  if ((size_t) __cmsg->cmsg_len < sizeof (struct cmsghdr))
>
>    return (struct cmsghdr *) 0;
>
>  __cmsg = (struct cmsghdr *) ((unsigned char *) __cmsg
>          + (((__cmsg->cmsg_len) + sizeof (size_t) - 1) & (size_t) ~(sizeof (size_t) - 1)));
>  if ((unsigned char *) (__cmsg + 1) > ((unsigned char *) __mhdr->msg_control
>     + __mhdr->msg_controllen)
>      || ((unsigned char *) __cmsg + (((__cmsg->cmsg_len) + sizeof (size_t) - 1) & (size_t) ~(sizeof (size_t) - 1))
>   > ((unsigned char *) __mhdr->msg_control + __mhdr->msg_controllen)))
>
>    return (struct cmsghdr *) 0;
>  return __cmsg;
>}
>
>
>
>
>enum
>  {
>    SCM_RIGHTS = 0x01
>
>
>    , SCM_CREDENTIALS = 0x02
>
>
>  };
>
>
>
>struct ucred
>{
>  pid_t pid;
>  uid_t uid;
>  gid_t gid;
>};
># 345 "/usr/include/bits/socket.h" 3 4
># 1 "/usr/include/asm/socket.h" 1 3 4
># 1 "/usr/include/asm-generic/socket.h" 1 3 4
>
>
>
># 1 "/usr/include/asm/sockios.h" 1 3 4
># 1 "/usr/include/asm-generic/sockios.h" 1 3 4
># 1 "/usr/include/asm/sockios.h" 2 3 4
># 5 "/usr/include/asm-generic/socket.h" 2 3 4
># 1 "/usr/include/asm/socket.h" 2 3 4
># 346 "/usr/include/bits/socket.h" 2 3 4
># 379 "/usr/include/bits/socket.h" 3 4
>struct linger
>  {
>    int l_onoff;
>    int l_linger;
>  };
># 39 "/usr/include/sys/socket.h" 2 3 4
>
>
>
>
>struct osockaddr
>  {
>    unsigned short int sa_family;
>    unsigned char sa_data[14];
>  };
>
>
>
>
>enum
>{
>  SHUT_RD = 0,
>
>  SHUT_WR,
>
>  SHUT_RDWR
>
>};
># 90 "/usr/include/sys/socket.h" 3 4
>typedef union { struct sockaddr *__restrict __sockaddr__; struct sockaddr_at *__restrict __sockaddr_at__; struct sockaddr_ax25 *__restrict __sockaddr_ax25__; struct sockaddr_dl *__restrict __sockaddr_dl__; struct sockaddr_eon *__restrict __sockaddr_eon__; struct sockaddr_in *__restrict __sockaddr_in__; struct sockaddr_in6 *__restrict __sockaddr_in6__; struct sockaddr_inarp *__restrict __sockaddr_inarp__; struct sockaddr_ipx *__restrict __sockaddr_ipx__; struct sockaddr_iso *__restrict __sockaddr_iso__; struct sockaddr_ns *__restrict __sockaddr_ns__; struct sockaddr_un *__restrict __sockaddr_un__; struct sockaddr_x25 *__restrict __sockaddr_x25__;
>       } __SOCKADDR_ARG __attribute__ ((__transparent_union__));
>
>
>typedef union { const struct sockaddr *__restrict __sockaddr__; const struct sockaddr_at *__restrict __sockaddr_at__; const struct sockaddr_ax25 *__restrict __sockaddr_ax25__; const struct sockaddr_dl *__restrict __sockaddr_dl__; const struct sockaddr_eon *__restrict __sockaddr_eon__; const struct sockaddr_in *__restrict __sockaddr_in__; const struct sockaddr_in6 *__restrict __sockaddr_in6__; const struct sockaddr_inarp *__restrict __sockaddr_inarp__; const struct sockaddr_ipx *__restrict __sockaddr_ipx__; const struct sockaddr_iso *__restrict __sockaddr_iso__; const struct sockaddr_ns *__restrict __sockaddr_ns__; const struct sockaddr_un *__restrict __sockaddr_un__; const struct sockaddr_x25 *__restrict __sockaddr_x25__;
>       } __CONST_SOCKADDR_ARG __attribute__ ((__transparent_union__));
>
>
>
>
>
>struct mmsghdr
>  {
>    struct msghdr msg_hdr;
>    unsigned int msg_len;
>
>  };
>
>
>
>
>
>
>extern int socket (int __domain, int __type, int __protocol) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int socketpair (int __domain, int __type, int __protocol,
>         int __fds[2]) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int bind (int __fd, __CONST_SOCKADDR_ARG __addr, socklen_t __len)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int getsockname (int __fd, __SOCKADDR_ARG __addr,
>   socklen_t *__restrict __len) __attribute__ ((__nothrow__ , __leaf__));
># 137 "/usr/include/sys/socket.h" 3 4
>extern int connect (int __fd, __CONST_SOCKADDR_ARG __addr, socklen_t __len);
>
>
>
>extern int getpeername (int __fd, __SOCKADDR_ARG __addr,
>   socklen_t *__restrict __len) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern ssize_t send (int __fd, const void *__buf, size_t __n, int __flags);
>
>
>
>
>
>
>extern ssize_t recv (int __fd, void *__buf, size_t __n, int __flags);
>
>
>
>
>
>
>extern ssize_t sendto (int __fd, const void *__buf, size_t __n,
>         int __flags, __CONST_SOCKADDR_ARG __addr,
>         socklen_t __addr_len);
># 174 "/usr/include/sys/socket.h" 3 4
>extern ssize_t recvfrom (int __fd, void *__restrict __buf, size_t __n,
>    int __flags, __SOCKADDR_ARG __addr,
>    socklen_t *__restrict __addr_len);
>
>
>
>
>
>
>
>extern ssize_t sendmsg (int __fd, const struct msghdr *__message,
>   int __flags);
>
>
>
>
>
>
>
>extern int sendmmsg (int __fd, struct mmsghdr *__vmessages,
>       unsigned int __vlen, int __flags);
>
>
>
>
>
>
>
>extern ssize_t recvmsg (int __fd, struct msghdr *__message, int __flags);
>
>
>
>
>
>
>
>extern int recvmmsg (int __fd, struct mmsghdr *__vmessages,
>       unsigned int __vlen, int __flags,
>       const struct timespec *__tmo);
>
>
>
>
>
>
>extern int getsockopt (int __fd, int __level, int __optname,
>         void *__restrict __optval,
>         socklen_t *__restrict __optlen) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int setsockopt (int __fd, int __level, int __optname,
>         const void *__optval, socklen_t __optlen) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int listen (int __fd, int __n) __attribute__ ((__nothrow__ , __leaf__));
># 243 "/usr/include/sys/socket.h" 3 4
>extern int accept (int __fd, __SOCKADDR_ARG __addr,
>     socklen_t *__restrict __addr_len);
>
>
>
>
>
>
>extern int accept4 (int __fd, __SOCKADDR_ARG __addr,
>      socklen_t *__restrict __addr_len, int __flags);
># 261 "/usr/include/sys/socket.h" 3 4
>extern int shutdown (int __fd, int __how) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int sockatmark (int __fd) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern int isfdtype (int __fd, int __fdtype) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
># 1 "/usr/include/bits/socket2.h" 1 3 4
># 23 "/usr/include/bits/socket2.h" 3 4
>extern ssize_t __recv_chk (int __fd, void *__buf, size_t __n, size_t __buflen,
>      int __flags);
>extern ssize_t __recv_alias (int __fd, void *__buf, size_t __n, int __flags) __asm__ ("" "recv")
>                          ;
>extern ssize_t __recv_chk_warn (int __fd, void *__buf, size_t __n, size_t __buflen, int __flags) __asm__ ("" "__recv_chk")
>
>
>     __attribute__((__warning__ ("recv called with bigger length than size of destination " "buffer")))
>            ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) ssize_t
>recv (int __fd, void *__buf, size_t __n, int __flags)
>{
>  if (__builtin_object_size (__buf, 0) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__n))
> return __recv_chk (__fd, __buf, __n, __builtin_object_size (__buf, 0), __flags);
>
>      if (__n > __builtin_object_size (__buf, 0))
> return __recv_chk_warn (__fd, __buf, __n, __builtin_object_size (__buf, 0), __flags);
>    }
>  return __recv_alias (__fd, __buf, __n, __flags);
>}
>
>extern ssize_t __recvfrom_chk (int __fd, void *__restrict __buf, size_t __n,
>          size_t __buflen, int __flags,
>          __SOCKADDR_ARG __addr,
>          socklen_t *__restrict __addr_len);
>extern ssize_t __recvfrom_alias (int __fd, void *__restrict __buf, size_t __n, int __flags, __SOCKADDR_ARG __addr, socklen_t *__restrict __addr_len) __asm__ ("" "recvfrom")
>
>
>                                                   ;
>extern ssize_t __recvfrom_chk_warn (int __fd, void *__restrict __buf, size_t __n, size_t __buflen, int __flags, __SOCKADDR_ARG __addr, socklen_t *__restrict __addr_len) __asm__ ("" "__recvfrom_chk")
>
>
>
>
>     __attribute__((__warning__ ("recvfrom called with bigger length than size of " "destination buffer")))
>                        ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) ssize_t
>recvfrom (int __fd, void *__restrict __buf, size_t __n, int __flags,
>   __SOCKADDR_ARG __addr, socklen_t *__restrict __addr_len)
>{
>  if (__builtin_object_size (__buf, 0) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__n))
> return __recvfrom_chk (__fd, __buf, __n, __builtin_object_size (__buf, 0), __flags,
>          __addr, __addr_len);
>      if (__n > __builtin_object_size (__buf, 0))
> return __recvfrom_chk_warn (__fd, __buf, __n, __builtin_object_size (__buf, 0), __flags,
>        __addr, __addr_len);
>    }
>  return __recvfrom_alias (__fd, __buf, __n, __flags, __addr, __addr_len);
>}
># 281 "/usr/include/sys/socket.h" 2 3 4
>
>
>
># 81 "hstdinc.h" 2
>
>
># 1 "/usr/include/arpa/inet.h" 1 3 4
># 22 "/usr/include/arpa/inet.h" 3 4
># 1 "/usr/include/netinet/in.h" 1 3 4
># 22 "/usr/include/netinet/in.h" 3 4
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stdint.h" 1 3 4
># 9 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stdint.h" 3 4
># 1 "/usr/include/stdint.h" 1 3 4
># 26 "/usr/include/stdint.h" 3 4
># 1 "/usr/include/bits/wchar.h" 1 3 4
># 27 "/usr/include/stdint.h" 2 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 28 "/usr/include/stdint.h" 2 3 4
># 48 "/usr/include/stdint.h" 3 4
>typedef unsigned char uint8_t;
>typedef unsigned short int uint16_t;
>
>typedef unsigned int uint32_t;
>
>
>
>
>
>__extension__
>typedef unsigned long long int uint64_t;
>
>
>
>
>
>
>typedef signed char int_least8_t;
>typedef short int int_least16_t;
>typedef int int_least32_t;
>
>
>
>__extension__
>typedef long long int int_least64_t;
>
>
>
>typedef unsigned char uint_least8_t;
>typedef unsigned short int uint_least16_t;
>typedef unsigned int uint_least32_t;
>
>
>
>__extension__
>typedef unsigned long long int uint_least64_t;
>
>
>
>
>
>
>typedef signed char int_fast8_t;
>
>
>
>
>
>typedef int int_fast16_t;
>typedef int int_fast32_t;
>__extension__
>typedef long long int int_fast64_t;
>
>
>
>typedef unsigned char uint_fast8_t;
>
>
>
>
>
>typedef unsigned int uint_fast16_t;
>typedef unsigned int uint_fast32_t;
>__extension__
>typedef unsigned long long int uint_fast64_t;
># 125 "/usr/include/stdint.h" 3 4
>typedef int intptr_t;
>
>
>typedef unsigned int uintptr_t;
># 137 "/usr/include/stdint.h" 3 4
>__extension__
>typedef long long int intmax_t;
>__extension__
>typedef unsigned long long int uintmax_t;
># 10 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stdint.h" 2 3 4
># 23 "/usr/include/netinet/in.h" 2 3 4
>
>
>
>
>
>
>
>typedef uint32_t in_addr_t;
>struct in_addr
>  {
>    in_addr_t s_addr;
>  };
>
>
># 1 "/usr/include/bits/in.h" 1 3 4
># 138 "/usr/include/bits/in.h" 3 4
>struct ip_opts
>  {
>    struct in_addr ip_dst;
>    char ip_opts[40];
>  };
>
>
>struct ip_mreqn
>  {
>    struct in_addr imr_multiaddr;
>    struct in_addr imr_address;
>    int imr_ifindex;
>  };
>
>
>struct in_pktinfo
>  {
>    int ipi_ifindex;
>    struct in_addr ipi_spec_dst;
>    struct in_addr ipi_addr;
>  };
># 38 "/usr/include/netinet/in.h" 2 3 4
>
>
>enum
>  {
>    IPPROTO_IP = 0,
>
>    IPPROTO_ICMP = 1,
>
>    IPPROTO_IGMP = 2,
>
>    IPPROTO_IPIP = 4,
>
>    IPPROTO_TCP = 6,
>
>    IPPROTO_EGP = 8,
>
>    IPPROTO_PUP = 12,
>
>    IPPROTO_UDP = 17,
>
>    IPPROTO_IDP = 22,
>
>    IPPROTO_TP = 29,
>
>    IPPROTO_DCCP = 33,
>
>    IPPROTO_IPV6 = 41,
>
>    IPPROTO_RSVP = 46,
>
>    IPPROTO_GRE = 47,
>
>    IPPROTO_ESP = 50,
>
>    IPPROTO_AH = 51,
>
>    IPPROTO_MTP = 92,
>
>    IPPROTO_BEETPH = 94,
>
>    IPPROTO_ENCAP = 98,
>
>    IPPROTO_PIM = 103,
>
>    IPPROTO_COMP = 108,
>
>    IPPROTO_SCTP = 132,
>
>    IPPROTO_UDPLITE = 136,
>
>    IPPROTO_RAW = 255,
>
>    IPPROTO_MAX
>  };
>
>
>
>
>
>enum
>  {
>    IPPROTO_HOPOPTS = 0,
>
>    IPPROTO_ROUTING = 43,
>
>    IPPROTO_FRAGMENT = 44,
>
>    IPPROTO_ICMPV6 = 58,
>
>    IPPROTO_NONE = 59,
>
>    IPPROTO_DSTOPTS = 60,
>
>    IPPROTO_MH = 135
>
>  };
>
>
>
>typedef uint16_t in_port_t;
>
>
>enum
>  {
>    IPPORT_ECHO = 7,
>    IPPORT_DISCARD = 9,
>    IPPORT_SYSTAT = 11,
>    IPPORT_DAYTIME = 13,
>    IPPORT_NETSTAT = 15,
>    IPPORT_FTP = 21,
>    IPPORT_TELNET = 23,
>    IPPORT_SMTP = 25,
>    IPPORT_TIMESERVER = 37,
>    IPPORT_NAMESERVER = 42,
>    IPPORT_WHOIS = 43,
>    IPPORT_MTP = 57,
>
>    IPPORT_TFTP = 69,
>    IPPORT_RJE = 77,
>    IPPORT_FINGER = 79,
>    IPPORT_TTYLINK = 87,
>    IPPORT_SUPDUP = 95,
>
>
>    IPPORT_EXECSERVER = 512,
>    IPPORT_LOGINSERVER = 513,
>    IPPORT_CMDSERVER = 514,
>    IPPORT_EFSSERVER = 520,
>
>
>    IPPORT_BIFFUDP = 512,
>    IPPORT_WHOSERVER = 513,
>    IPPORT_ROUTESERVER = 520,
>
>
>    IPPORT_RESERVED = 1024,
>
>
>    IPPORT_USERRESERVED = 5000
>  };
># 209 "/usr/include/netinet/in.h" 3 4
>struct in6_addr
>  {
>    union
>      {
> uint8_t __u6_addr8[16];
>
> uint16_t __u6_addr16[8];
> uint32_t __u6_addr32[4];
>
>      } __in6_u;
>
>
>
>
>
>  };
>
>
>extern const struct in6_addr in6addr_any;
>extern const struct in6_addr in6addr_loopback;
># 237 "/usr/include/netinet/in.h" 3 4
>struct sockaddr_in
>  {
>    sa_family_t sin_family;
>    in_port_t sin_port;
>    struct in_addr sin_addr;
>
>
>    unsigned char sin_zero[sizeof (struct sockaddr) -
>      (sizeof (unsigned short int)) -
>      sizeof (in_port_t) -
>      sizeof (struct in_addr)];
>  };
>
>
>
>struct sockaddr_in6
>  {
>    sa_family_t sin6_family;
>    in_port_t sin6_port;
>    uint32_t sin6_flowinfo;
>    struct in6_addr sin6_addr;
>    uint32_t sin6_scope_id;
>  };
>
>
>
>
>struct ip_mreq
>  {
>
>    struct in_addr imr_multiaddr;
>
>
>    struct in_addr imr_interface;
>  };
>
>struct ip_mreq_source
>  {
>
>    struct in_addr imr_multiaddr;
>
>
>    struct in_addr imr_interface;
>
>
>    struct in_addr imr_sourceaddr;
>  };
>
>
>
>
>struct ipv6_mreq
>  {
>
>    struct in6_addr ipv6mr_multiaddr;
>
>
>    unsigned int ipv6mr_interface;
>  };
>
>
>
>
>struct group_req
>  {
>
>    uint32_t gr_interface;
>
>
>    struct sockaddr_storage gr_group;
>  };
>
>struct group_source_req
>  {
>
>    uint32_t gsr_interface;
>
>
>    struct sockaddr_storage gsr_group;
>
>
>    struct sockaddr_storage gsr_source;
>  };
>
>
>
>struct ip_msfilter
>  {
>
>    struct in_addr imsf_multiaddr;
>
>
>    struct in_addr imsf_interface;
>
>
>    uint32_t imsf_fmode;
>
>
>    uint32_t imsf_numsrc;
>
>    struct in_addr imsf_slist[1];
>  };
>
>
>
>
>
>struct group_filter
>  {
>
>    uint32_t gf_interface;
>
>
>    struct sockaddr_storage gf_group;
>
>
>    uint32_t gf_fmode;
>
>
>    uint32_t gf_numsrc;
>
>    struct sockaddr_storage gf_slist[1];
>};
># 374 "/usr/include/netinet/in.h" 3 4
>extern uint32_t ntohl (uint32_t __netlong) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>extern uint16_t ntohs (uint16_t __netshort)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>extern uint32_t htonl (uint32_t __hostlong)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>extern uint16_t htons (uint16_t __hostshort)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
># 1 "/usr/include/bits/byteswap.h" 1 3 4
># 386 "/usr/include/netinet/in.h" 2 3 4
># 501 "/usr/include/netinet/in.h" 3 4
>extern int bindresvport (int __sockfd, struct sockaddr_in *__sock_in) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int bindresvport6 (int __sockfd, struct sockaddr_in6 *__sock_in)
>     __attribute__ ((__nothrow__ , __leaf__));
># 531 "/usr/include/netinet/in.h" 3 4
>struct cmsghdr;
>
>
>struct in6_pktinfo
>  {
>    struct in6_addr ipi6_addr;
>    unsigned int ipi6_ifindex;
>  };
>
>
>struct ip6_mtuinfo
>  {
>    struct sockaddr_in6 ip6m_addr;
>    uint32_t ip6m_mtu;
>  };
>
>
>
>extern int inet6_option_space (int __nbytes)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__deprecated__));
>extern int inet6_option_init (void *__bp, struct cmsghdr **__cmsgp,
>         int __type) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__deprecated__));
>extern int inet6_option_append (struct cmsghdr *__cmsg,
>    const uint8_t *__typep, int __multx,
>    int __plusy) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__deprecated__));
>extern uint8_t *inet6_option_alloc (struct cmsghdr *__cmsg, int __datalen,
>        int __multx, int __plusy)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__deprecated__));
>extern int inet6_option_next (const struct cmsghdr *__cmsg,
>         uint8_t **__tptrp)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__deprecated__));
>extern int inet6_option_find (const struct cmsghdr *__cmsg,
>         uint8_t **__tptrp, int __type)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__deprecated__));
>
>
>
>extern int inet6_opt_init (void *__extbuf, socklen_t __extlen) __attribute__ ((__nothrow__ , __leaf__));
>extern int inet6_opt_append (void *__extbuf, socklen_t __extlen, int __offset,
>        uint8_t __type, socklen_t __len, uint8_t __align,
>        void **__databufp) __attribute__ ((__nothrow__ , __leaf__));
>extern int inet6_opt_finish (void *__extbuf, socklen_t __extlen, int __offset)
>     __attribute__ ((__nothrow__ , __leaf__));
>extern int inet6_opt_set_val (void *__databuf, int __offset, void *__val,
>         socklen_t __vallen) __attribute__ ((__nothrow__ , __leaf__));
>extern int inet6_opt_next (void *__extbuf, socklen_t __extlen, int __offset,
>      uint8_t *__typep, socklen_t *__lenp,
>      void **__databufp) __attribute__ ((__nothrow__ , __leaf__));
>extern int inet6_opt_find (void *__extbuf, socklen_t __extlen, int __offset,
>      uint8_t __type, socklen_t *__lenp,
>      void **__databufp) __attribute__ ((__nothrow__ , __leaf__));
>extern int inet6_opt_get_val (void *__databuf, int __offset, void *__val,
>         socklen_t __vallen) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern socklen_t inet6_rth_space (int __type, int __segments) __attribute__ ((__nothrow__ , __leaf__));
>extern void *inet6_rth_init (void *__bp, socklen_t __bp_len, int __type,
>        int __segments) __attribute__ ((__nothrow__ , __leaf__));
>extern int inet6_rth_add (void *__bp, const struct in6_addr *__addr) __attribute__ ((__nothrow__ , __leaf__));
>extern int inet6_rth_reverse (const void *__in, void *__out) __attribute__ ((__nothrow__ , __leaf__));
>extern int inet6_rth_segments (const void *__bp) __attribute__ ((__nothrow__ , __leaf__));
>extern struct in6_addr *inet6_rth_getaddr (const void *__bp, int __index)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int getipv4sourcefilter (int __s, struct in_addr __interface_addr,
>    struct in_addr __group, uint32_t *__fmode,
>    uint32_t *__numsrc, struct in_addr *__slist)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int setipv4sourcefilter (int __s, struct in_addr __interface_addr,
>    struct in_addr __group, uint32_t __fmode,
>    uint32_t __numsrc,
>    const struct in_addr *__slist)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int getsourcefilter (int __s, uint32_t __interface_addr,
>       const struct sockaddr *__group,
>       socklen_t __grouplen, uint32_t *__fmode,
>       uint32_t *__numsrc,
>       struct sockaddr_storage *__slist) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int setsourcefilter (int __s, uint32_t __interface_addr,
>       const struct sockaddr *__group,
>       socklen_t __grouplen, uint32_t __fmode,
>       uint32_t __numsrc,
>       const struct sockaddr_storage *__slist) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
># 23 "/usr/include/arpa/inet.h" 2 3 4
>
>
>
>
>
>
>
>
>
>
>
>extern in_addr_t inet_addr (const char *__cp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern in_addr_t inet_lnaof (struct in_addr __in) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern struct in_addr inet_makeaddr (in_addr_t __net, in_addr_t __host)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern in_addr_t inet_netof (struct in_addr __in) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern in_addr_t inet_network (const char *__cp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern char *inet_ntoa (struct in_addr __in) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int inet_pton (int __af, const char *__restrict __cp,
>        void *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern const char *inet_ntop (int __af, const void *__restrict __cp,
>         char *__restrict __buf, socklen_t __len)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int inet_aton (const char *__cp, struct in_addr *__inp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern char *inet_neta (in_addr_t __net, char *__buf, size_t __len) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern char *inet_net_ntop (int __af, const void *__cp, int __bits,
>       char *__buf, size_t __len) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int inet_net_pton (int __af, const char *__cp,
>     void *__buf, size_t __len) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern unsigned int inet_nsap_addr (const char *__cp,
>        unsigned char *__buf, int __len) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern char *inet_nsap_ntoa (int __len, const unsigned char *__cp,
>        char *__buf) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
># 84 "hstdinc.h" 2
>
>
>
># 1 "/usr/include/linux/if_tun.h" 1 3 4
># 19 "/usr/include/linux/if_tun.h" 3 4
># 1 "/usr/include/linux/types.h" 1 3 4
>
>
>
># 1 "/usr/include/asm/types.h" 1 3 4
>
>
>
># 1 "/usr/include/asm-generic/types.h" 1 3 4
>
>
>
>
>
># 1 "/usr/include/asm-generic/int-ll64.h" 1 3 4
># 11 "/usr/include/asm-generic/int-ll64.h" 3 4
># 1 "/usr/include/asm/bitsperlong.h" 1 3 4
># 10 "/usr/include/asm/bitsperlong.h" 3 4
># 1 "/usr/include/asm-generic/bitsperlong.h" 1 3 4
># 11 "/usr/include/asm/bitsperlong.h" 2 3 4
># 12 "/usr/include/asm-generic/int-ll64.h" 2 3 4
>
>
>
>
>
>
>
>typedef __signed__ char __s8;
>typedef unsigned char __u8;
>
>typedef __signed__ short __s16;
>typedef unsigned short __u16;
>
>typedef __signed__ int __s32;
>typedef unsigned int __u32;
>
>
>__extension__ typedef __signed__ long long __s64;
>__extension__ typedef unsigned long long __u64;
># 7 "/usr/include/asm-generic/types.h" 2 3 4
># 5 "/usr/include/asm/types.h" 2 3 4
># 5 "/usr/include/linux/types.h" 2 3 4
>
>
>
># 1 "/usr/include/linux/posix_types.h" 1 3 4
>
>
>
># 1 "/usr/include/linux/stddef.h" 1 3 4
># 5 "/usr/include/linux/posix_types.h" 2 3 4
># 24 "/usr/include/linux/posix_types.h" 3 4
>typedef struct {
> unsigned long fds_bits[1024 / (8 * sizeof(long))];
>} __kernel_fd_set;
>
>
>typedef void (*__kernel_sighandler_t)(int);
>
>
>typedef int __kernel_key_t;
>typedef int __kernel_mqd_t;
>
># 1 "/usr/include/asm/posix_types.h" 1 3 4
>
># 1 "/usr/include/asm/posix_types_32.h" 1 3 4
># 10 "/usr/include/asm/posix_types_32.h" 3 4
>typedef unsigned short __kernel_mode_t;
>
>
>typedef unsigned short __kernel_ipc_pid_t;
>
>
>typedef unsigned short __kernel_uid_t;
>typedef unsigned short __kernel_gid_t;
>
>
>typedef unsigned short __kernel_old_dev_t;
>
>
># 1 "/usr/include/asm-generic/posix_types.h" 1 3 4
># 14 "/usr/include/asm-generic/posix_types.h" 3 4
>typedef long __kernel_long_t;
>typedef unsigned long __kernel_ulong_t;
>
>
>
>typedef __kernel_ulong_t __kernel_ino_t;
>
>
>
>
>
>
>
>typedef int __kernel_pid_t;
># 40 "/usr/include/asm-generic/posix_types.h" 3 4
>typedef __kernel_long_t __kernel_suseconds_t;
>
>
>
>typedef int __kernel_daddr_t;
>
>
>
>typedef unsigned int __kernel_uid32_t;
>typedef unsigned int __kernel_gid32_t;
>
>
>
>typedef __kernel_uid_t __kernel_old_uid_t;
>typedef __kernel_gid_t __kernel_old_gid_t;
># 67 "/usr/include/asm-generic/posix_types.h" 3 4
>typedef unsigned int __kernel_size_t;
>typedef int __kernel_ssize_t;
>typedef int __kernel_ptrdiff_t;
># 78 "/usr/include/asm-generic/posix_types.h" 3 4
>typedef struct {
> int val[2];
>} __kernel_fsid_t;
>
>
>
>
>
>typedef __kernel_long_t __kernel_off_t;
>typedef long long __kernel_loff_t;
>typedef __kernel_long_t __kernel_time_t;
>typedef __kernel_long_t __kernel_clock_t;
>typedef int __kernel_timer_t;
>typedef int __kernel_clockid_t;
>typedef char * __kernel_caddr_t;
>typedef unsigned short __kernel_uid16_t;
>typedef unsigned short __kernel_gid16_t;
># 24 "/usr/include/asm/posix_types_32.h" 2 3 4
># 3 "/usr/include/asm/posix_types.h" 2 3 4
># 36 "/usr/include/linux/posix_types.h" 2 3 4
># 9 "/usr/include/linux/types.h" 2 3 4
># 27 "/usr/include/linux/types.h" 3 4
>typedef __u16 __le16;
>typedef __u16 __be16;
>typedef __u32 __le32;
>typedef __u32 __be32;
>typedef __u64 __le64;
>typedef __u64 __be64;
>
>typedef __u16 __sum16;
>typedef __u32 __wsum;
># 20 "/usr/include/linux/if_tun.h" 2 3 4
># 1 "/usr/include/linux/if_ether.h" 1 3 4
># 136 "/usr/include/linux/if_ether.h" 3 4
>struct ethhdr {
> unsigned char h_dest[6];
> unsigned char h_source[6];
> __be16 h_proto;
>} __attribute__((packed));
># 21 "/usr/include/linux/if_tun.h" 2 3 4
># 1 "/usr/include/linux/filter.h" 1 3 4
># 23 "/usr/include/linux/filter.h" 3 4
>struct sock_filter {
> __u16 code;
> __u8 jt;
> __u8 jf;
> __u32 k;
>};
>
>struct sock_fprog {
> unsigned short len;
> struct sock_filter *filter;
>};
># 22 "/usr/include/linux/if_tun.h" 2 3 4
># 89 "/usr/include/linux/if_tun.h" 3 4
>struct tun_pi {
> __u16 flags;
> __be16 proto;
>};
># 103 "/usr/include/linux/if_tun.h" 3 4
>struct tun_filter {
> __u16 flags;
> __u16 count;
> __u8 addr[0][6];
>};
># 88 "hstdinc.h" 2
>
>
># 1 "/usr/include/net/route.h" 1 3 4
># 27 "/usr/include/net/route.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 28 "/usr/include/net/route.h" 2 3 4
>
>
>
>struct rtentry
>  {
>    unsigned long int rt_pad1;
>    struct sockaddr rt_dst;
>    struct sockaddr rt_gateway;
>    struct sockaddr rt_genmask;
>    unsigned short int rt_flags;
>    short int rt_pad2;
>    unsigned long int rt_pad3;
>    unsigned char rt_tos;
>    unsigned char rt_class;
>
>
>
>    short int rt_pad4;
>
>    short int rt_metric;
>    char *rt_dev;
>    unsigned long int rt_mtu;
>    unsigned long int rt_window;
>    unsigned short int rt_irtt;
>  };
>
>
>
>
>struct in6_rtmsg
>  {
>    struct in6_addr rtmsg_dst;
>    struct in6_addr rtmsg_src;
>    struct in6_addr rtmsg_gateway;
>    u_int32_t rtmsg_type;
>    u_int16_t rtmsg_dst_len;
>    u_int16_t rtmsg_src_len;
>    u_int32_t rtmsg_metric;
>    unsigned long int rtmsg_info;
>    u_int32_t rtmsg_flags;
>    int rtmsg_ifindex;
>  };
># 91 "hstdinc.h" 2
>
>
>
>
>
>
>
># 1 "/usr/include/net/if.h" 1 3 4
># 33 "/usr/include/net/if.h" 3 4
>struct if_nameindex
>  {
>    unsigned int if_index;
>    char *if_name;
>  };
>
>
>
>
>enum
>  {
>    IFF_UP = 0x1,
>
>    IFF_BROADCAST = 0x2,
>
>    IFF_DEBUG = 0x4,
>
>    IFF_LOOPBACK = 0x8,
>
>    IFF_POINTOPOINT = 0x10,
>
>    IFF_NOTRAILERS = 0x20,
>
>    IFF_RUNNING = 0x40,
>
>    IFF_NOARP = 0x80,
>
>    IFF_PROMISC = 0x100,
>
>
>
>    IFF_ALLMULTI = 0x200,
>
>
>    IFF_MASTER = 0x400,
>
>    IFF_SLAVE = 0x800,
>
>
>    IFF_MULTICAST = 0x1000,
>
>
>    IFF_PORTSEL = 0x2000,
>
>    IFF_AUTOMEDIA = 0x4000,
>
>    IFF_DYNAMIC = 0x8000
>
>  };
>
>
>
>
>
>
>struct ifaddr
>  {
>    struct sockaddr ifa_addr;
>    union
>      {
> struct sockaddr ifu_broadaddr;
> struct sockaddr ifu_dstaddr;
>      } ifa_ifu;
>    struct iface *ifa_ifp;
>    struct ifaddr *ifa_next;
>  };
># 111 "/usr/include/net/if.h" 3 4
>struct ifmap
>  {
>    unsigned long int mem_start;
>    unsigned long int mem_end;
>    unsigned short int base_addr;
>    unsigned char irq;
>    unsigned char dma;
>    unsigned char port;
>
>  };
>
>
>
>
>
>struct ifreq
>  {
>
>
>    union
>      {
> char ifrn_name[16];
>      } ifr_ifrn;
>
>    union
>      {
> struct sockaddr ifru_addr;
> struct sockaddr ifru_dstaddr;
> struct sockaddr ifru_broadaddr;
> struct sockaddr ifru_netmask;
> struct sockaddr ifru_hwaddr;
> short int ifru_flags;
> int ifru_ivalue;
> int ifru_mtu;
> struct ifmap ifru_map;
> char ifru_slave[16];
> char ifru_newname[16];
> __caddr_t ifru_data;
>      } ifr_ifru;
>  };
># 176 "/usr/include/net/if.h" 3 4
>struct ifconf
>  {
>    int ifc_len;
>    union
>      {
> __caddr_t ifcu_buf;
> struct ifreq *ifcu_req;
>      } ifc_ifcu;
>  };
>
>
>
>
>
>
>
>
>extern unsigned int if_nametoindex (const char *__ifname) __attribute__ ((__nothrow__ , __leaf__));
>extern char *if_indextoname (unsigned int __ifindex, char *__ifname) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern struct if_nameindex *if_nameindex (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern void if_freenameindex (struct if_nameindex *__ptr) __attribute__ ((__nothrow__ , __leaf__));
>
>
># 99 "hstdinc.h" 2
>
>
>
>
>
># 1 "/usr/include/netinet/tcp.h" 1 3 4
># 69 "/usr/include/netinet/tcp.h" 3 4
>typedef u_int32_t tcp_seq;
>
>
>
>
>struct tcphdr
>  {
>    __extension__ union
>    {
>      struct
>      {
> u_int16_t th_sport;
> u_int16_t th_dport;
> tcp_seq th_seq;
> tcp_seq th_ack;
>
> u_int8_t th_x2:4;
> u_int8_t th_off:4;
>
>
>
>
>
> u_int8_t th_flags;
>
>
>
>
>
>
> u_int16_t th_win;
> u_int16_t th_sum;
> u_int16_t th_urp;
>      };
>      struct
>      {
> u_int16_t source;
> u_int16_t dest;
> u_int32_t seq;
> u_int32_t ack_seq;
>
> u_int16_t res1:4;
> u_int16_t doff:4;
> u_int16_t fin:1;
> u_int16_t syn:1;
> u_int16_t rst:1;
> u_int16_t psh:1;
> u_int16_t ack:1;
> u_int16_t urg:1;
> u_int16_t res2:2;
># 132 "/usr/include/netinet/tcp.h" 3 4
> u_int16_t window;
> u_int16_t check;
> u_int16_t urg_ptr;
>      };
>    };
>};
>
>enum
>{
>  TCP_ESTABLISHED = 1,
>  TCP_SYN_SENT,
>  TCP_SYN_RECV,
>  TCP_FIN_WAIT1,
>  TCP_FIN_WAIT2,
>  TCP_TIME_WAIT,
>  TCP_CLOSE,
>  TCP_CLOSE_WAIT,
>  TCP_LAST_ACK,
>  TCP_LISTEN,
>  TCP_CLOSING
>};
># 193 "/usr/include/netinet/tcp.h" 3 4
>enum tcp_ca_state
>{
>  TCP_CA_Open = 0,
>  TCP_CA_Disorder = 1,
>  TCP_CA_CWR = 2,
>  TCP_CA_Recovery = 3,
>  TCP_CA_Loss = 4
>};
>
>struct tcp_info
>{
>  u_int8_t tcpi_state;
>  u_int8_t tcpi_ca_state;
>  u_int8_t tcpi_retransmits;
>  u_int8_t tcpi_probes;
>  u_int8_t tcpi_backoff;
>  u_int8_t tcpi_options;
>  u_int8_t tcpi_snd_wscale : 4, tcpi_rcv_wscale : 4;
>
>  u_int32_t tcpi_rto;
>  u_int32_t tcpi_ato;
>  u_int32_t tcpi_snd_mss;
>  u_int32_t tcpi_rcv_mss;
>
>  u_int32_t tcpi_unacked;
>  u_int32_t tcpi_sacked;
>  u_int32_t tcpi_lost;
>  u_int32_t tcpi_retrans;
>  u_int32_t tcpi_fackets;
>
>
>  u_int32_t tcpi_last_data_sent;
>  u_int32_t tcpi_last_ack_sent;
>  u_int32_t tcpi_last_data_recv;
>  u_int32_t tcpi_last_ack_recv;
>
>
>  u_int32_t tcpi_pmtu;
>  u_int32_t tcpi_rcv_ssthresh;
>  u_int32_t tcpi_rtt;
>  u_int32_t tcpi_rttvar;
>  u_int32_t tcpi_snd_ssthresh;
>  u_int32_t tcpi_snd_cwnd;
>  u_int32_t tcpi_advmss;
>  u_int32_t tcpi_reordering;
>
>  u_int32_t tcpi_rcv_rtt;
>  u_int32_t tcpi_rcv_space;
>
>  u_int32_t tcpi_total_retrans;
>};
>
>
>
>
>
>struct tcp_md5sig
>{
>  struct sockaddr_storage tcpm_addr;
>  u_int16_t __tcpm_pad1;
>  u_int16_t tcpm_keylen;
>  u_int32_t __tcpm_pad2;
>  u_int8_t tcpm_key[80];
>};
>
>
>struct tcp_repair_opt
>{
>  u_int32_t opt_code;
>  u_int32_t opt_val;
>};
>
>
>enum
>{
>  TCP_NO_QUEUE,
>  TCP_RECV_QUEUE,
>  TCP_SEND_QUEUE,
>  TCP_QUEUES_NR,
>};
># 291 "/usr/include/netinet/tcp.h" 3 4
>struct tcp_cookie_transactions
>{
>  u_int16_t tcpct_flags;
>  u_int8_t __tcpct_pad1;
>  u_int8_t tcpct_cookie_desired;
>  u_int16_t tcpct_s_data_desired;
>  u_int16_t tcpct_used;
>  u_int8_t tcpct_value[536U];
>};
># 105 "hstdinc.h" 2
>
>
>
>
>
># 1 "/usr/include/sys/mman.h" 1 3 4
># 25 "/usr/include/sys/mman.h" 3 4
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 26 "/usr/include/sys/mman.h" 2 3 4
># 41 "/usr/include/sys/mman.h" 3 4
># 1 "/usr/include/bits/mman.h" 1 3 4
># 45 "/usr/include/bits/mman.h" 3 4
># 1 "/usr/include/bits/mman-linux.h" 1 3 4
># 45 "/usr/include/bits/mman.h" 2 3 4
># 42 "/usr/include/sys/mman.h" 2 3 4
>
>
>
>
>
># 61 "/usr/include/sys/mman.h" 3 4
>extern void * mmap (void *__addr, size_t __len, int __prot, int __flags, int __fd, __off64_t __offset) __asm__ ("" "mmap64") __attribute__ ((__nothrow__ , __leaf__))
>
>
>                ;
>
>
>
>
>
>extern void *mmap64 (void *__addr, size_t __len, int __prot,
>       int __flags, int __fd, __off64_t __offset) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int munmap (void *__addr, size_t __len) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int mprotect (void *__addr, size_t __len, int __prot) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern int msync (void *__addr, size_t __len, int __flags);
>
>
>
>
>extern int madvise (void *__addr, size_t __len, int __advice) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int posix_madvise (void *__addr, size_t __len, int __advice) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int mlock (const void *__addr, size_t __len) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int munlock (const void *__addr, size_t __len) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int mlockall (int __flags) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int munlockall (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern int mincore (void *__start, size_t __len, unsigned char *__vec)
>     __attribute__ ((__nothrow__ , __leaf__));
># 133 "/usr/include/sys/mman.h" 3 4
>extern void *mremap (void *__addr, size_t __old_len, size_t __new_len,
>       int __flags, ...) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int remap_file_pages (void *__start, size_t __size, int __prot,
>        size_t __pgoff, int __flags) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int shm_open (const char *__name, int __oflag, mode_t __mode);
>
>
>extern int shm_unlink (const char *__name);
>
>
># 111 "hstdinc.h" 2
>
>
># 1 "/usr/include/sys/param.h" 1 3 4
># 23 "/usr/include/sys/param.h" 3 4
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 24 "/usr/include/sys/param.h" 2 3 4
>
>
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/limits.h" 1 3 4
># 27 "/usr/include/sys/param.h" 2 3 4
>
># 1 "/usr/include/signal.h" 1 3 4
># 30 "/usr/include/signal.h" 3 4
>
>
># 1 "/usr/include/bits/sigset.h" 1 3 4
># 102 "/usr/include/bits/sigset.h" 3 4
>extern int __sigismember (const __sigset_t *, int);
>extern int __sigaddset (__sigset_t *, int);
>extern int __sigdelset (__sigset_t *, int);
># 116 "/usr/include/bits/sigset.h" 3 4
>extern __inline int __sigismember (const __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return (__set->__val[__word] & __mask) ? 1 : 0; }
>extern __inline int __sigaddset ( __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return ((__set->__val[__word] |= __mask), 0); }
>extern __inline int __sigdelset ( __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return ((__set->__val[__word] &= ~__mask), 0); }
># 33 "/usr/include/signal.h" 2 3 4
>
>
>
>
>
>
>
>typedef __sig_atomic_t sig_atomic_t;
>
># 57 "/usr/include/signal.h" 3 4
># 1 "/usr/include/bits/signum.h" 1 3 4
># 58 "/usr/include/signal.h" 2 3 4
># 80 "/usr/include/signal.h" 3 4
># 1 "/usr/include/bits/siginfo.h" 1 3 4
># 24 "/usr/include/bits/siginfo.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 25 "/usr/include/bits/siginfo.h" 2 3 4
>
>
>
>
>
>
>
>typedef union sigval
>  {
>    int sival_int;
>    void *sival_ptr;
>  } sigval_t;
># 58 "/usr/include/bits/siginfo.h" 3 4
>typedef __clock_t __sigchld_clock_t;
>
>
>
>typedef struct
>  {
>    int si_signo;
>    int si_errno;
>
>    int si_code;
>
>    union
>      {
> int _pad[((128 / sizeof (int)) - 3)];
>
>
> struct
>   {
>     __pid_t si_pid;
>     __uid_t si_uid;
>   } _kill;
>
>
> struct
>   {
>     int si_tid;
>     int si_overrun;
>     sigval_t si_sigval;
>   } _timer;
>
>
> struct
>   {
>     __pid_t si_pid;
>     __uid_t si_uid;
>     sigval_t si_sigval;
>   } _rt;
>
>
> struct
>   {
>     __pid_t si_pid;
>     __uid_t si_uid;
>     int si_status;
>     __sigchld_clock_t si_utime;
>     __sigchld_clock_t si_stime;
>   } _sigchld;
>
>
> struct
>   {
>     void *si_addr;
>     short int si_addr_lsb;
>   } _sigfault;
>
>
> struct
>   {
>     long int si_band;
>     int si_fd;
>   } _sigpoll;
>
>
> struct
>   {
>     void *_call_addr;
>     int _syscall;
>     unsigned int _arch;
>   } _sigsys;
>      } _sifields;
>  } siginfo_t ;
># 153 "/usr/include/bits/siginfo.h" 3 4
>enum
>{
>  SI_ASYNCNL = -60,
>
>  SI_TKILL = -6,
>
>  SI_SIGIO,
>
>  SI_ASYNCIO,
>
>  SI_MESGQ,
>
>  SI_TIMER,
>
>  SI_QUEUE,
>
>  SI_USER,
>
>  SI_KERNEL = 0x80
>
>};
>
>
>
>
>enum
>{
>  ILL_ILLOPC = 1,
>
>  ILL_ILLOPN,
>
>  ILL_ILLADR,
>
>  ILL_ILLTRP,
>
>  ILL_PRVOPC,
>
>  ILL_PRVREG,
>
>  ILL_COPROC,
>
>  ILL_BADSTK
>
>};
>
>
>enum
>{
>  FPE_INTDIV = 1,
>
>  FPE_INTOVF,
>
>  FPE_FLTDIV,
>
>  FPE_FLTOVF,
>
>  FPE_FLTUND,
>
>  FPE_FLTRES,
>
>  FPE_FLTINV,
>
>  FPE_FLTSUB
>
>};
>
>
>enum
>{
>  SEGV_MAPERR = 1,
>
>  SEGV_ACCERR
>
>};
>
>
>enum
>{
>  BUS_ADRALN = 1,
>
>  BUS_ADRERR,
>
>  BUS_OBJERR,
>
>  BUS_MCEERR_AR,
>
>  BUS_MCEERR_AO
>
>};
>
>
>
>
>enum
>{
>  TRAP_BRKPT = 1,
>
>  TRAP_TRACE
>
>};
>
>
>
>
>enum
>{
>  CLD_EXITED = 1,
>
>  CLD_KILLED,
>
>  CLD_DUMPED,
>
>  CLD_TRAPPED,
>
>  CLD_STOPPED,
>
>  CLD_CONTINUED
>
>};
>
>
>enum
>{
>  POLL_IN = 1,
>
>  POLL_OUT,
>
>  POLL_MSG,
>
>  POLL_ERR,
>
>  POLL_PRI,
>
>  POLL_HUP
>
>};
># 313 "/usr/include/bits/siginfo.h" 3 4
>typedef struct sigevent
>  {
>    sigval_t sigev_value;
>    int sigev_signo;
>    int sigev_notify;
>
>    union
>      {
> int _pad[((64 / sizeof (int)) - 3)];
>
>
>
> __pid_t _tid;
>
> struct
>   {
>     void (*_function) (sigval_t);
>     pthread_attr_t *_attribute;
>   } _sigev_thread;
>      } _sigev_un;
>  } sigevent_t;
>
>
>
>
>
>
>enum
>{
>  SIGEV_SIGNAL = 0,
>
>  SIGEV_NONE,
>
>  SIGEV_THREAD,
>
>
>  SIGEV_THREAD_ID = 4
>
>};
># 81 "/usr/include/signal.h" 2 3 4
>
>
>
>
>typedef void (*__sighandler_t) (int);
>
>
>
>
>extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern __sighandler_t signal (int __sig, __sighandler_t __handler)
>     __attribute__ ((__nothrow__ , __leaf__));
># 114 "/usr/include/signal.h" 3 4
>
>
>
>
>
>extern __sighandler_t bsd_signal (int __sig, __sighandler_t __handler)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int kill (__pid_t __pid, int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int killpg (__pid_t __pgrp, int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int raise (int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)
>     __attribute__ ((__nothrow__ , __leaf__));
>extern int gsignal (int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern void psignal (int __sig, const char *__s);
>
>
>
>
>extern void psiginfo (const siginfo_t *__pinfo, const char *__s);
># 167 "/usr/include/signal.h" 3 4
>extern int __sigpause (int __sig_or_mask, int __is_sig);
>
>
>
>extern int sigpause (int __sig) __asm__ ("__xpg_sigpause");
># 189 "/usr/include/signal.h" 3 4
>extern int sigblock (int __mask) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__deprecated__));
>
>
>extern int sigsetmask (int __mask) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__deprecated__));
>
>
>extern int siggetmask (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__deprecated__));
># 204 "/usr/include/signal.h" 3 4
>typedef __sighandler_t sighandler_t;
>
>
>
>
>typedef __sighandler_t sig_t;
>
>
>
>
>
>extern int sigemptyset (sigset_t *__set) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigfillset (sigset_t *__set) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigaddset (sigset_t *__set, int __signo) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigdelset (sigset_t *__set, int __signo) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigismember (const sigset_t *__set, int __signo)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int sigisemptyset (const sigset_t *__set) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigandset (sigset_t *__set, const sigset_t *__left,
>        const sigset_t *__right) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>extern int sigorset (sigset_t *__set, const sigset_t *__left,
>       const sigset_t *__right) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>
>
># 1 "/usr/include/bits/sigaction.h" 1 3 4
># 24 "/usr/include/bits/sigaction.h" 3 4
>struct sigaction
>  {
>
>
>    union
>      {
>
> __sighandler_t sa_handler;
>
> void (*sa_sigaction) (int, siginfo_t *, void *);
>      }
>    __sigaction_handler;
>
>
>
>
>
>
>
>    __sigset_t sa_mask;
>
>
>    int sa_flags;
>
>
>    void (*sa_restorer) (void);
>  };
># 246 "/usr/include/signal.h" 2 3 4
>
>
>extern int sigprocmask (int __how, const sigset_t *__restrict __set,
>   sigset_t *__restrict __oset) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int sigsuspend (const sigset_t *__set) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigaction (int __sig, const struct sigaction *__restrict __act,
>        struct sigaction *__restrict __oact) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sigpending (sigset_t *__set) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int sigwait (const sigset_t *__restrict __set, int *__restrict __sig)
>     __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern int sigwaitinfo (const sigset_t *__restrict __set,
>   siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int sigtimedwait (const sigset_t *__restrict __set,
>    siginfo_t *__restrict __info,
>    const struct timespec *__restrict __timeout)
>     __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int sigqueue (__pid_t __pid, int __sig, const union sigval __val)
>     __attribute__ ((__nothrow__ , __leaf__));
># 303 "/usr/include/signal.h" 3 4
>extern const char *const _sys_siglist[65];
>extern const char *const sys_siglist[65];
>
>
>struct sigvec
>  {
>    __sighandler_t sv_handler;
>    int sv_mask;
>
>    int sv_flags;
>
>  };
># 327 "/usr/include/signal.h" 3 4
>extern int sigvec (int __sig, const struct sigvec *__vec,
>     struct sigvec *__ovec) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
># 1 "/usr/include/bits/sigcontext.h" 1 3 4
># 29 "/usr/include/bits/sigcontext.h" 3 4
>struct _fpx_sw_bytes
>{
>  __uint32_t magic1;
>  __uint32_t extended_size;
>  __uint64_t xstate_bv;
>  __uint32_t xstate_size;
>  __uint32_t padding[7];
>};
>
>struct _fpreg
>{
>  unsigned short significand[4];
>  unsigned short exponent;
>};
>
>struct _fpxreg
>{
>  unsigned short significand[4];
>  unsigned short exponent;
>  unsigned short padding[3];
>};
>
>struct _xmmreg
>{
>  __uint32_t element[4];
>};
>
>
>
>
>
>struct _fpstate
>{
>
>  __uint32_t cw;
>  __uint32_t sw;
>  __uint32_t tag;
>  __uint32_t ipoff;
>  __uint32_t cssel;
>  __uint32_t dataoff;
>  __uint32_t datasel;
>  struct _fpreg _st[8];
>  unsigned short status;
>  unsigned short magic;
>
>
>  __uint32_t _fxsr_env[6];
>  __uint32_t mxcsr;
>  __uint32_t reserved;
>  struct _fpxreg _fxsr_st[8];
>  struct _xmmreg _xmm[8];
>  __uint32_t padding[56];
>};
># 93 "/usr/include/bits/sigcontext.h" 3 4
>struct sigcontext
>{
>  unsigned short gs, __gsh;
>  unsigned short fs, __fsh;
>  unsigned short es, __esh;
>  unsigned short ds, __dsh;
>  unsigned long edi;
>  unsigned long esi;
>  unsigned long ebp;
>  unsigned long esp;
>  unsigned long ebx;
>  unsigned long edx;
>  unsigned long ecx;
>  unsigned long eax;
>  unsigned long trapno;
>  unsigned long err;
>  unsigned long eip;
>  unsigned short cs, __csh;
>  unsigned long eflags;
>  unsigned long esp_at_signal;
>  unsigned short ss, __ssh;
>  struct _fpstate * fpstate;
>  unsigned long oldmask;
>  unsigned long cr2;
>};
># 175 "/usr/include/bits/sigcontext.h" 3 4
>struct _xsave_hdr
>{
>  __uint64_t xstate_bv;
>  __uint64_t reserved1[2];
>  __uint64_t reserved2[5];
>};
>
>struct _ymmh_state
>{
>  __uint32_t ymmh_space[64];
>};
>
>struct _xstate
>{
>  struct _fpstate fpstate;
>  struct _xsave_hdr xstate_hdr;
>  struct _ymmh_state ymmh;
>};
># 333 "/usr/include/signal.h" 2 3 4
>
>
>extern int sigreturn (struct sigcontext *__scp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 343 "/usr/include/signal.h" 2 3 4
>
>
>
>
>extern int siginterrupt (int __sig, int __interrupt) __attribute__ ((__nothrow__ , __leaf__));
>
># 1 "/usr/include/bits/sigstack.h" 1 3 4
># 25 "/usr/include/bits/sigstack.h" 3 4
>struct sigstack
>  {
>    void *ss_sp;
>    int ss_onstack;
>  };
>
>
>
>enum
>{
>  SS_ONSTACK = 1,
>
>  SS_DISABLE
>
>};
># 49 "/usr/include/bits/sigstack.h" 3 4
>typedef struct sigaltstack
>  {
>    void *ss_sp;
>    int ss_flags;
>    size_t ss_size;
>  } stack_t;
># 350 "/usr/include/signal.h" 2 3 4
>
>
># 1 "/usr/include/sys/ucontext.h" 1 3 4
># 22 "/usr/include/sys/ucontext.h" 3 4
># 1 "/usr/include/signal.h" 1 3 4
># 23 "/usr/include/sys/ucontext.h" 2 3 4
># 146 "/usr/include/sys/ucontext.h" 3 4
>typedef int greg_t;
>
>
>
>
>
>typedef greg_t gregset_t[19];
>
>
>
>enum
>{
>  REG_GS = 0,
>
>  REG_FS,
>
>  REG_ES,
>
>  REG_DS,
>
>  REG_EDI,
>
>  REG_ESI,
>
>  REG_EBP,
>
>  REG_ESP,
>
>  REG_EBX,
>
>  REG_EDX,
>
>  REG_ECX,
>
>  REG_EAX,
>
>  REG_TRAPNO,
>
>  REG_ERR,
>
>  REG_EIP,
>
>  REG_CS,
>
>  REG_EFL,
>
>  REG_UESP,
>
>  REG_SS
>
>};
>
>
>
>struct _libc_fpreg
>{
>  unsigned short int significand[4];
>  unsigned short int exponent;
>};
>
>struct _libc_fpstate
>{
>  unsigned long int cw;
>  unsigned long int sw;
>  unsigned long int tag;
>  unsigned long int ipoff;
>  unsigned long int cssel;
>  unsigned long int dataoff;
>  unsigned long int datasel;
>  struct _libc_fpreg _st[8];
>  unsigned long int status;
>};
>
>
>typedef struct _libc_fpstate *fpregset_t;
>
>
>typedef struct
>  {
>    gregset_t gregs;
>
>
>    fpregset_t fpregs;
>    unsigned long int oldmask;
>    unsigned long int cr2;
>  } mcontext_t;
>
>
>typedef struct ucontext
>  {
>    unsigned long int uc_flags;
>    struct ucontext *uc_link;
>    stack_t uc_stack;
>    mcontext_t uc_mcontext;
>    __sigset_t uc_sigmask;
>    struct _libc_fpstate __fpregs_mem;
>  } ucontext_t;
># 353 "/usr/include/signal.h" 2 3 4
>
>
>
>
>
>extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__deprecated__));
>
>
>
>extern int sigaltstack (const struct sigaltstack *__restrict __ss,
>   struct sigaltstack *__restrict __oss) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern int sighold (int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sigrelse (int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sigignore (int __sig) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __sighandler_t sigset (int __sig, __sighandler_t __disp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
># 1 "/usr/include/bits/sigthread.h" 1 3 4
># 30 "/usr/include/bits/sigthread.h" 3 4
>extern int pthread_sigmask (int __how,
>       const __sigset_t *__restrict __newmask,
>       __sigset_t *__restrict __oldmask)__attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int pthread_kill (pthread_t __threadid, int __signo) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int pthread_sigqueue (pthread_t __threadid, int __signo,
>        const union sigval __value) __attribute__ ((__nothrow__ , __leaf__));
># 389 "/usr/include/signal.h" 2 3 4
>
>
>
>
>
>
>extern int __libc_current_sigrtmin (void) __attribute__ ((__nothrow__ , __leaf__));
>
>extern int __libc_current_sigrtmax (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
># 29 "/usr/include/sys/param.h" 2 3 4
>
>
># 1 "/usr/include/bits/param.h" 1 3 4
># 28 "/usr/include/bits/param.h" 3 4
># 1 "/usr/include/linux/param.h" 1 3 4
>
>
>
># 1 "/usr/include/asm/param.h" 1 3 4
># 1 "/usr/include/asm-generic/param.h" 1 3 4
># 1 "/usr/include/asm/param.h" 2 3 4
># 5 "/usr/include/linux/param.h" 2 3 4
># 29 "/usr/include/bits/param.h" 2 3 4
># 32 "/usr/include/sys/param.h" 2 3 4
># 114 "hstdinc.h" 2
>
>
># 1 "/usr/include/sys/mount.h" 1 3 4
># 33 "/usr/include/sys/mount.h" 3 4
>enum
>{
>  MS_RDONLY = 1,
>
>  MS_NOSUID = 2,
>
>  MS_NODEV = 4,
>
>  MS_NOEXEC = 8,
>
>  MS_SYNCHRONOUS = 16,
>
>  MS_REMOUNT = 32,
>
>  MS_MANDLOCK = 64,
>
>  MS_DIRSYNC = 128,
>
>  MS_NOATIME = 1024,
>
>  MS_NODIRATIME = 2048,
>
>  MS_BIND = 4096,
>
>  MS_MOVE = 8192,
>
>  MS_REC = 16384,
>
>  MS_SILENT = 32768,
>
>  MS_POSIXACL = 1 << 16,
>
>  MS_UNBINDABLE = 1 << 17,
>
>  MS_PRIVATE = 1 << 18,
>
>  MS_SLAVE = 1 << 19,
>
>  MS_SHARED = 1 << 20,
>
>  MS_RELATIME = 1 << 21,
>
>  MS_KERNMOUNT = 1 << 22,
>
>  MS_I_VERSION = 1 << 23,
>
>  MS_STRICTATIME = 1 << 24,
>
>  MS_ACTIVE = 1 << 30,
>
>  MS_NOUSER = 1 << 31
>
>};
># 119 "/usr/include/sys/mount.h" 3 4
>enum
>{
>  MNT_FORCE = 1,
>
>  MNT_DETACH = 2,
>
>  MNT_EXPIRE = 4,
>
>  UMOUNT_NOFOLLOW = 8
>
>};
>
>
>
>
>
>extern int mount (const char *__special_file, const char *__dir,
>    const char *__fstype, unsigned long int __rwflag,
>    const void *__data) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int umount (const char *__special_file) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int umount2 (const char *__special_file, int __flags) __attribute__ ((__nothrow__ , __leaf__));
>
>
># 117 "hstdinc.h" 2
>
>
># 1 "/usr/include/sys/mtio.h" 1 3 4
># 30 "/usr/include/sys/mtio.h" 3 4
>struct mtop
>  {
>    short int mt_op;
>    int mt_count;
>  };
># 81 "/usr/include/sys/mtio.h" 3 4
>struct mtget
>  {
>    long int mt_type;
>    long int mt_resid;
>
>
>
>
>    long int mt_dsreg;
>    long int mt_gstat;
>    long int mt_erreg;
>
>    __daddr_t mt_fileno;
>    __daddr_t mt_blkno;
>  };
># 127 "/usr/include/sys/mtio.h" 3 4
>struct mt_tape_info
>  {
>    long int t_type;
>    char *t_name;
>  };
># 157 "/usr/include/sys/mtio.h" 3 4
>struct mtpos
>  {
>    long int mt_blkno;
>  };
>
>
>
>
>
>
>struct mtconfiginfo
>  {
>    long int mt_type;
>    long int ifc_type;
>    unsigned short int irqnr;
>    unsigned short int dmanr;
>    unsigned short int port;
>
>    unsigned long int debug;
>
>    unsigned have_dens:1;
>    unsigned have_bsf:1;
>    unsigned have_fsr:1;
>    unsigned have_bsr:1;
>    unsigned have_eod:1;
>    unsigned have_seek:1;
>    unsigned have_tell:1;
>    unsigned have_ras1:1;
>    unsigned have_ras2:1;
>    unsigned have_ras3:1;
>    unsigned have_qfa:1;
>
>    unsigned pad1:5;
>    char reserved[10];
>  };
># 120 "hstdinc.h" 2
>
>
># 1 "/usr/include/sys/resource.h" 1 3 4
># 24 "/usr/include/sys/resource.h" 3 4
># 1 "/usr/include/bits/resource.h" 1 3 4
># 31 "/usr/include/bits/resource.h" 3 4
>enum __rlimit_resource
>{
>
>  RLIMIT_CPU = 0,
>
>
>
>  RLIMIT_FSIZE = 1,
>
>
>
>  RLIMIT_DATA = 2,
>
>
>
>  RLIMIT_STACK = 3,
>
>
>
>  RLIMIT_CORE = 4,
>
>
>
>
>
>
>  __RLIMIT_RSS = 5,
>
>
>
>  RLIMIT_NOFILE = 7,
>  __RLIMIT_OFILE = RLIMIT_NOFILE,
>
>
>
>
>  RLIMIT_AS = 9,
>
>
>
>  __RLIMIT_NPROC = 6,
>
>
>
>  __RLIMIT_MEMLOCK = 8,
>
>
>
>  __RLIMIT_LOCKS = 10,
>
>
>
>  __RLIMIT_SIGPENDING = 11,
>
>
>
>  __RLIMIT_MSGQUEUE = 12,
>
>
>
>
>
>  __RLIMIT_NICE = 13,
>
>
>
>
>  __RLIMIT_RTPRIO = 14,
>
>
>
>
>
>  __RLIMIT_RTTIME = 15,
>
>
>  __RLIMIT_NLIMITS = 16,
>  __RLIM_NLIMITS = __RLIMIT_NLIMITS
>
>
>};
># 133 "/usr/include/bits/resource.h" 3 4
>typedef __rlim64_t rlim_t;
>
>
>typedef __rlim64_t rlim64_t;
>
>
>struct rlimit
>  {
>
>    rlim_t rlim_cur;
>
>    rlim_t rlim_max;
>  };
>
>
>struct rlimit64
>  {
>
>    rlim64_t rlim_cur;
>
>    rlim64_t rlim_max;
> };
>
>
>
>enum __rusage_who
>{
>
>  RUSAGE_SELF = 0,
>
>
>
>  RUSAGE_CHILDREN = -1
>
>
>
>  ,
>
>  RUSAGE_THREAD = 1
>
>
>
>
>};
>
>
># 1 "/usr/include/bits/time.h" 1 3 4
># 180 "/usr/include/bits/resource.h" 2 3 4
>
>
>
>
>
>
>
>struct rusage
>  {
>
>    struct timeval ru_utime;
>
>    struct timeval ru_stime;
>
>    __extension__ union
>      {
> long int ru_maxrss;
> __syscall_slong_t __ru_maxrss_word;
>      };
>
>
>
>    __extension__ union
>      {
> long int ru_ixrss;
> __syscall_slong_t __ru_ixrss_word;
>      };
>
>    __extension__ union
>      {
> long int ru_idrss;
> __syscall_slong_t __ru_idrss_word;
>      };
>
>    __extension__ union
>      {
> long int ru_isrss;
>  __syscall_slong_t __ru_isrss_word;
>      };
>
>
>    __extension__ union
>      {
> long int ru_minflt;
> __syscall_slong_t __ru_minflt_word;
>      };
>
>    __extension__ union
>      {
> long int ru_majflt;
> __syscall_slong_t __ru_majflt_word;
>      };
>
>    __extension__ union
>      {
> long int ru_nswap;
> __syscall_slong_t __ru_nswap_word;
>      };
>
>
>    __extension__ union
>      {
> long int ru_inblock;
> __syscall_slong_t __ru_inblock_word;
>      };
>
>    __extension__ union
>      {
> long int ru_oublock;
> __syscall_slong_t __ru_oublock_word;
>      };
>
>    __extension__ union
>      {
> long int ru_msgsnd;
> __syscall_slong_t __ru_msgsnd_word;
>      };
>
>    __extension__ union
>      {
> long int ru_msgrcv;
> __syscall_slong_t __ru_msgrcv_word;
>      };
>
>    __extension__ union
>      {
> long int ru_nsignals;
> __syscall_slong_t __ru_nsignals_word;
>      };
>
>
>
>    __extension__ union
>      {
> long int ru_nvcsw;
> __syscall_slong_t __ru_nvcsw_word;
>      };
>
>
>    __extension__ union
>      {
> long int ru_nivcsw;
> __syscall_slong_t __ru_nivcsw_word;
>      };
>  };
>
>
>
>
>
>
>
>enum __priority_which
>{
>  PRIO_PROCESS = 0,
>
>  PRIO_PGRP = 1,
>
>  PRIO_USER = 2
>
>};
>
>
>
># 313 "/usr/include/bits/resource.h" 3 4
>extern int prlimit (__pid_t __pid, enum __rlimit_resource __resource, const struct rlimit *__new_limit, struct rlimit *__old_limit) __asm__ ("" "prlimit64") __attribute__ ((__nothrow__ , __leaf__))
>
>
>                                                ;
>
>
>
>
>
>extern int prlimit64 (__pid_t __pid, enum __rlimit_resource __resource,
>        const struct rlimit64 *__new_limit,
>        struct rlimit64 *__old_limit) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
># 25 "/usr/include/sys/resource.h" 2 3 4
>
>
>
>
>
>
>
>
>
>
>
>
>
>typedef enum __rlimit_resource __rlimit_resource_t;
>typedef enum __rusage_who __rusage_who_t;
>typedef enum __priority_which __priority_which_t;
># 54 "/usr/include/sys/resource.h" 3 4
>extern int getrlimit (__rlimit_resource_t __resource, struct rlimit *__rlimits) __asm__ ("" "getrlimit64") __attribute__ ((__nothrow__ , __leaf__))
>                                                  ;
>
>
>
>
>
>extern int getrlimit64 (__rlimit_resource_t __resource,
>   struct rlimit64 *__rlimits) __attribute__ ((__nothrow__ , __leaf__));
># 73 "/usr/include/sys/resource.h" 3 4
>extern int setrlimit (__rlimit_resource_t __resource, const struct rlimit *__rlimits) __asm__ ("" "setrlimit64") __attribute__ ((__nothrow__ , __leaf__))
>
>                  ;
>
>
>
>
>
>extern int setrlimit64 (__rlimit_resource_t __resource,
>   const struct rlimit64 *__rlimits) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int getrusage (__rusage_who_t __who, struct rusage *__usage) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int getpriority (__priority_which_t __which, id_t __who) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int setpriority (__priority_which_t __which, id_t __who, int __prio)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
># 123 "hstdinc.h" 2
>
>
># 1 "/usr/include/sys/un.h" 1 3 4
># 26 "/usr/include/sys/un.h" 3 4
>
>
>
>struct sockaddr_un
>  {
>    sa_family_t sun_family;
>    char sun_path[108];
>  };
># 44 "/usr/include/sys/un.h" 3 4
>
># 126 "hstdinc.h" 2
>
>
>
>
>
># 1 "/usr/include/sys/utsname.h" 1 3 4
># 27 "/usr/include/sys/utsname.h" 3 4
>
>
># 1 "/usr/include/bits/utsname.h" 1 3 4
># 30 "/usr/include/sys/utsname.h" 2 3 4
># 48 "/usr/include/sys/utsname.h" 3 4
>struct utsname
>  {
>
>    char sysname[65];
>
>
>    char nodename[65];
>
>
>    char release[65];
>
>    char version[65];
>
>
>    char machine[65];
>
>
>
>
>    char domainname[65];
>
>
>
>
>  };
># 81 "/usr/include/sys/utsname.h" 3 4
>extern int uname (struct utsname *__name) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
># 132 "hstdinc.h" 2
>
>
># 1 "/usr/include/sys/wait.h" 1 3 4
># 27 "/usr/include/sys/wait.h" 3 4
>
># 99 "/usr/include/sys/wait.h" 3 4
>typedef enum
>{
>  P_ALL,
>  P_PID,
>  P_PGID
>} idtype_t;
># 113 "/usr/include/sys/wait.h" 3 4
>extern __pid_t wait (__WAIT_STATUS __stat_loc);
># 136 "/usr/include/sys/wait.h" 3 4
>extern __pid_t waitpid (__pid_t __pid, int *__stat_loc, int __options);
># 146 "/usr/include/sys/wait.h" 3 4
># 1 "/usr/include/bits/siginfo.h" 1 3 4
># 24 "/usr/include/bits/siginfo.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 25 "/usr/include/bits/siginfo.h" 2 3 4
># 147 "/usr/include/sys/wait.h" 2 3 4
># 159 "/usr/include/sys/wait.h" 3 4
>extern int waitid (idtype_t __idtype, __id_t __id, siginfo_t *__infop,
>     int __options);
>
>
>
>
>
>struct rusage;
>
>
>
>
>
>
>extern __pid_t wait3 (__WAIT_STATUS __stat_loc, int __options,
>        struct rusage * __usage) __attribute__ ((__nothrow__));
>
>
>
>
>extern __pid_t wait4 (__pid_t __pid, __WAIT_STATUS __stat_loc, int __options,
>        struct rusage *__usage) __attribute__ ((__nothrow__));
>
>
>
>
># 135 "hstdinc.h" 2
>
>
>
># 1 "/usr/include/byteswap.h" 1 3 4
># 24 "/usr/include/byteswap.h" 3 4
># 1 "/usr/include/bits/byteswap.h" 1 3 4
># 25 "/usr/include/byteswap.h" 2 3 4
># 139 "hstdinc.h" 2
># 147 "hstdinc.h"
># 1 "/usr/include/bzlib.h" 1 3 4
># 48 "/usr/include/bzlib.h" 3 4
>typedef
>   struct {
>      char *next_in;
>      unsigned int avail_in;
>      unsigned int total_in_lo32;
>      unsigned int total_in_hi32;
>
>      char *next_out;
>      unsigned int avail_out;
>      unsigned int total_out_lo32;
>      unsigned int total_out_hi32;
>
>      void *state;
>
>      void *(*bzalloc)(void *,int,int);
>      void (*bzfree)(void *,void *);
>      void *opaque;
>   }
>   bz_stream;
># 100 "/usr/include/bzlib.h" 3 4
>extern int BZ2_bzCompressInit (
>      bz_stream* strm,
>      int blockSize100k,
>      int verbosity,
>      int workFactor
>   );
>
>extern int BZ2_bzCompress (
>      bz_stream* strm,
>      int action
>   );
>
>extern int BZ2_bzCompressEnd (
>      bz_stream* strm
>   );
>
>extern int BZ2_bzDecompressInit (
>      bz_stream *strm,
>      int verbosity,
>      int small
>   );
>
>extern int BZ2_bzDecompress (
>      bz_stream* strm
>   );
>
>extern int BZ2_bzDecompressEnd (
>      bz_stream *strm
>   );
># 137 "/usr/include/bzlib.h" 3 4
>typedef void BZFILE;
>
>extern BZFILE* BZ2_bzReadOpen (
>      int* bzerror,
>      FILE* f,
>      int verbosity,
>      int small,
>      void* unused,
>      int nUnused
>   );
>
>extern void BZ2_bzReadClose (
>      int* bzerror,
>      BZFILE* b
>   );
>
>extern void BZ2_bzReadGetUnused (
>      int* bzerror,
>      BZFILE* b,
>      void** unused,
>      int* nUnused
>   );
>
>extern int BZ2_bzRead (
>      int* bzerror,
>      BZFILE* b,
>      void* buf,
>      int len
>   );
>
>extern BZFILE* BZ2_bzWriteOpen (
>      int* bzerror,
>      FILE* f,
>      int blockSize100k,
>      int verbosity,
>      int workFactor
>   );
>
>extern void BZ2_bzWrite (
>      int* bzerror,
>      BZFILE* b,
>      void* buf,
>      int len
>   );
>
>extern void BZ2_bzWriteClose (
>      int* bzerror,
>      BZFILE* b,
>      int abandon,
>      unsigned int* nbytes_in,
>      unsigned int* nbytes_out
>   );
>
>extern void BZ2_bzWriteClose64 (
>      int* bzerror,
>      BZFILE* b,
>      int abandon,
>      unsigned int* nbytes_in_lo32,
>      unsigned int* nbytes_in_hi32,
>      unsigned int* nbytes_out_lo32,
>      unsigned int* nbytes_out_hi32
>   );
>
>
>
>
>
>extern int BZ2_bzBuffToBuffCompress (
>      char* dest,
>      unsigned int* destLen,
>      char* source,
>      unsigned int sourceLen,
>      int blockSize100k,
>      int verbosity,
>      int workFactor
>   );
>
>extern int BZ2_bzBuffToBuffDecompress (
>      char* dest,
>      unsigned int* destLen,
>      char* source,
>      unsigned int sourceLen,
>      int small,
>      int verbosity
>   );
># 233 "/usr/include/bzlib.h" 3 4
>extern const char * BZ2_bzlibVersion (
>      void
>   );
>
>
>extern BZFILE * BZ2_bzopen (
>      const char *path,
>      const char *mode
>   );
>
>extern BZFILE * BZ2_bzdopen (
>      int fd,
>      const char *mode
>   );
>
>extern int BZ2_bzread (
>      BZFILE* b,
>      void* buf,
>      int len
>   );
>
>extern int BZ2_bzwrite (
>      BZFILE* b,
>      void* buf,
>      int len
>   );
>
>extern int BZ2_bzflush (
>      BZFILE* b
>   );
>
>extern void BZ2_bzclose (
>      BZFILE* b
>   );
>
>extern const char * BZ2_bzerror (
>      BZFILE *b,
>      int *errnum
>   );
># 148 "hstdinc.h" 2
># 157 "hstdinc.h"
># 1 "/usr/include/dirent.h" 1 3 4
># 27 "/usr/include/dirent.h" 3 4
>
># 61 "/usr/include/dirent.h" 3 4
># 1 "/usr/include/bits/dirent.h" 1 3 4
># 22 "/usr/include/bits/dirent.h" 3 4
>struct dirent
>  {
>
>
>
>
>    __ino64_t d_ino;
>    __off64_t d_off;
>
>    unsigned short int d_reclen;
>    unsigned char d_type;
>    char d_name[256];
>  };
>
>
>struct dirent64
>  {
>    __ino64_t d_ino;
>    __off64_t d_off;
>    unsigned short int d_reclen;
>    unsigned char d_type;
>    char d_name[256];
>  };
># 62 "/usr/include/dirent.h" 2 3 4
># 97 "/usr/include/dirent.h" 3 4
>enum
>  {
>    DT_UNKNOWN = 0,
>
>    DT_FIFO = 1,
>
>    DT_CHR = 2,
>
>    DT_DIR = 4,
>
>    DT_BLK = 6,
>
>    DT_REG = 8,
>
>    DT_LNK = 10,
>
>    DT_SOCK = 12,
>
>    DT_WHT = 14
>
>  };
># 127 "/usr/include/dirent.h" 3 4
>typedef struct __dirstream DIR;
>
>
>
>
>
>
>extern DIR *opendir (const char *__name) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern DIR *fdopendir (int __fd);
>
>
>
>
>
>
>
>extern int closedir (DIR *__dirp) __attribute__ ((__nonnull__ (1)));
># 165 "/usr/include/dirent.h" 3 4
>extern struct dirent *readdir (DIR *__dirp) __asm__ ("" "readdir64")
>     __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern struct dirent64 *readdir64 (DIR *__dirp) __attribute__ ((__nonnull__ (1)));
># 189 "/usr/include/dirent.h" 3 4
>extern int readdir_r (DIR *__restrict __dirp, struct dirent *__restrict __entry, struct dirent **__restrict __result) __asm__ ("" "readdir64_r")
>
>
>
>                      __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>
>
>
>
>extern int readdir64_r (DIR *__restrict __dirp,
>   struct dirent64 *__restrict __entry,
>   struct dirent64 **__restrict __result)
>     __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>
>
>extern void rewinddir (DIR *__dirp) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern void seekdir (DIR *__dirp, long int __pos) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern long int telldir (DIR *__dirp) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int dirfd (DIR *__dirp) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 244 "/usr/include/dirent.h" 3 4
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 245 "/usr/include/dirent.h" 2 3 4
># 262 "/usr/include/dirent.h" 3 4
>extern int scandir (const char *__restrict __dir, struct dirent ***__restrict __namelist, int (*__selector) (const struct dirent *), int (*__cmp) (const struct dirent **, const struct dirent **)) __asm__ ("" "scandir64")
>
>
>
>
>
>                    __attribute__ ((__nonnull__ (1, 2)));
># 277 "/usr/include/dirent.h" 3 4
>extern int scandir64 (const char *__restrict __dir,
>        struct dirent64 ***__restrict __namelist,
>        int (*__selector) (const struct dirent64 *),
>        int (*__cmp) (const struct dirent64 **,
>        const struct dirent64 **))
>     __attribute__ ((__nonnull__ (1, 2)));
># 300 "/usr/include/dirent.h" 3 4
>extern int scandirat (int __dfd, const char *__restrict __dir, struct dirent ***__restrict __namelist, int (*__selector) (const struct dirent *), int (*__cmp) (const struct dirent **, const struct dirent **)) __asm__ ("" "scandirat64")
>
>
>
>
>
>                      __attribute__ ((__nonnull__ (2, 3)));
>
>
>
>
>
>
>
>extern int scandirat64 (int __dfd, const char *__restrict __dir,
>   struct dirent64 ***__restrict __namelist,
>   int (*__selector) (const struct dirent64 *),
>   int (*__cmp) (const struct dirent64 **,
>          const struct dirent64 **))
>     __attribute__ ((__nonnull__ (2, 3)));
># 329 "/usr/include/dirent.h" 3 4
>extern int alphasort (const struct dirent **__e1, const struct dirent **__e2) __asm__ ("" "alphasort64") __attribute__ ((__nothrow__ , __leaf__))
>
>
>                   __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern int alphasort64 (const struct dirent64 **__e1,
>   const struct dirent64 **__e2)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
># 358 "/usr/include/dirent.h" 3 4
>extern __ssize_t getdirentries (int __fd, char *__restrict __buf, size_t __nbytes, __off64_t *__restrict __basep) __asm__ ("" "getdirentries64") __attribute__ ((__nothrow__ , __leaf__))
>
>
>
>                      __attribute__ ((__nonnull__ (2, 4)));
>
>
>
>
>
>
>extern __ssize_t getdirentries64 (int __fd, char *__restrict __buf,
>      size_t __nbytes,
>      __off64_t *__restrict __basep)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 4)));
># 384 "/usr/include/dirent.h" 3 4
>extern int versionsort (const struct dirent **__e1, const struct dirent **__e2) __asm__ ("" "versionsort64") __attribute__ ((__nothrow__ , __leaf__))
>
>
>
>     __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern int versionsort64 (const struct dirent64 **__e1,
>     const struct dirent64 **__e2)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
># 158 "hstdinc.h" 2
># 166 "hstdinc.h"
># 1 "/usr/include/dlfcn.h" 1 3 4
># 24 "/usr/include/dlfcn.h" 3 4
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 25 "/usr/include/dlfcn.h" 2 3 4
>
>
># 1 "/usr/include/bits/dlfcn.h" 1 3 4
># 57 "/usr/include/bits/dlfcn.h" 3 4
>
>
>
>extern void _dl_mcount_wrapper_check (void *__selfpc) __attribute__ ((__nothrow__ , __leaf__));
>
>
># 28 "/usr/include/dlfcn.h" 2 3 4
># 44 "/usr/include/dlfcn.h" 3 4
>typedef long int Lmid_t;
>
>
>
>
>
>
>
>
>
>
>
>extern void *dlopen (const char *__file, int __mode) __attribute__ ((__nothrow__));
>
>
>
>extern int dlclose (void *__handle) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern void *dlsym (void *__restrict __handle,
>      const char *__restrict __name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>extern void *dlmopen (Lmid_t __nsid, const char *__file, int __mode) __attribute__ ((__nothrow__));
>
>
>
>extern void *dlvsym (void *__restrict __handle,
>       const char *__restrict __name,
>       const char *__restrict __version)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3)));
>
>
>
>
>
>extern char *dlerror (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>typedef struct
>{
>  const char *dli_fname;
>  void *dli_fbase;
>  const char *dli_sname;
>  void *dli_saddr;
>} Dl_info;
>
>
>
>extern int dladdr (const void *__address, Dl_info *__info)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>extern int dladdr1 (const void *__address, Dl_info *__info,
>      void **__extra_info, int __flags) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>enum
>  {
>
>    RTLD_DL_SYMENT = 1,
>
>
>    RTLD_DL_LINKMAP = 2
>  };
>
>
>
>
>
>
>
>extern int dlinfo (void *__restrict __handle,
>     int __request, void *__restrict __arg)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 3)));
>
>
>enum
>  {
>
>    RTLD_DI_LMID = 1,
>
>
>
>    RTLD_DI_LINKMAP = 2,
>
>    RTLD_DI_CONFIGADDR = 3,
>
>
>
>
>
>
>    RTLD_DI_SERINFO = 4,
>    RTLD_DI_SERINFOSIZE = 5,
>
>
>
>    RTLD_DI_ORIGIN = 6,
>
>    RTLD_DI_PROFILENAME = 7,
>    RTLD_DI_PROFILEOUT = 8,
>
>
>
>
>    RTLD_DI_TLS_MODID = 9,
>
>
>
>
>
>    RTLD_DI_TLS_DATA = 10,
>
>    RTLD_DI_MAX = 10
>  };
>
>
>
>
>typedef struct
>{
>  char *dls_name;
>  unsigned int dls_flags;
>} Dl_serpath;
>
>
>
>typedef struct
>{
>  size_t dls_size;
>  unsigned int dls_cnt;
>  Dl_serpath dls_serpath[1];
>} Dl_serinfo;
>
>
>
>
># 167 "hstdinc.h" 2
>
>
>
>
># 1 "/usr/include/iconv.h" 1 3 4
># 23 "/usr/include/iconv.h" 3 4
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 24 "/usr/include/iconv.h" 2 3 4
>
>
>
>
>
>typedef void *iconv_t;
>
>
>
>
>
>
>
>extern iconv_t iconv_open (const char *__tocode, const char *__fromcode);
>
>
>
>
>extern size_t iconv (iconv_t __cd, char **__restrict __inbuf,
>       size_t *__restrict __inbytesleft,
>       char **__restrict __outbuf,
>       size_t *__restrict __outbytesleft);
>
>
>
>
>
>extern int iconv_close (iconv_t __cd);
>
>
># 172 "hstdinc.h" 2
>
>
># 1 "/usr/include/inttypes.h" 1 3 4
># 34 "/usr/include/inttypes.h" 3 4
>typedef long int __gwchar_t;
># 266 "/usr/include/inttypes.h" 3 4
>
># 280 "/usr/include/inttypes.h" 3 4
>typedef struct
>  {
>    __extension__ long long int quot;
>    __extension__ long long int rem;
>  } imaxdiv_t;
>
>
>
>
>
>extern intmax_t imaxabs (intmax_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom)
>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern intmax_t strtoimax (const char *__restrict __nptr,
>      char **__restrict __endptr, int __base) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern uintmax_t strtoumax (const char *__restrict __nptr,
>       char ** __restrict __endptr, int __base) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern intmax_t wcstoimax (const __gwchar_t *__restrict __nptr,
>      __gwchar_t **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern uintmax_t wcstoumax (const __gwchar_t *__restrict __nptr,
>       __gwchar_t ** __restrict __endptr, int __base)
>     __attribute__ ((__nothrow__ , __leaf__));
># 370 "/usr/include/inttypes.h" 3 4
>__extension__
>extern long long int __strtoll_internal (const char *__restrict __nptr,
>      char **__restrict __endptr,
>      int __base, int __group)
>  __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>extern __inline intmax_t
>__attribute__ ((__nothrow__ , __leaf__)) strtoimax (const char *__restrict nptr, char **__restrict endptr, int base)
>
>{
>  return __strtoll_internal (nptr, endptr, base, 0);
>}
>
>__extension__
>extern unsigned long long int __strtoull_internal (const char *
>         __restrict __nptr,
>         char **
>         __restrict __endptr,
>         int __base,
>         int __group)
>  __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>extern __inline uintmax_t
>__attribute__ ((__nothrow__ , __leaf__)) strtoumax (const char *__restrict nptr, char **__restrict endptr, int base)
>
>{
>  return __strtoull_internal (nptr, endptr, base, 0);
>}
>
>__extension__
>extern long long int __wcstoll_internal (const __gwchar_t *__restrict __nptr,
>      __gwchar_t **__restrict __endptr,
>      int __base, int __group)
>  __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>extern __inline intmax_t
>__attribute__ ((__nothrow__ , __leaf__)) wcstoimax (const __gwchar_t *__restrict nptr, __gwchar_t **__restrict endptr, int base)
>
>{
>  return __wcstoll_internal (nptr, endptr, base, 0);
>}
>
>
>__extension__
>extern unsigned long long int __wcstoull_internal (const __gwchar_t *
>         __restrict __nptr,
>         __gwchar_t **
>         __restrict __endptr,
>         int __base,
>         int __group)
>  __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>extern __inline uintmax_t
>__attribute__ ((__nothrow__ , __leaf__)) wcstoumax (const __gwchar_t *__restrict nptr, __gwchar_t **__restrict endptr, int base)
>
>{
>  return __wcstoull_internal (nptr, endptr, base, 0);
>}
>
>
>
>
>
># 175 "hstdinc.h" 2
>
>
># 1 "/usr/include/malloc.h" 1 3 4
># 23 "/usr/include/malloc.h" 3 4
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 147 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stddef.h" 3 4
>typedef int ptrdiff_t;
># 24 "/usr/include/malloc.h" 2 3 4
># 35 "/usr/include/malloc.h" 3 4
>
>
>
>extern void *malloc (size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
>
>extern void *calloc (size_t __nmemb, size_t __size)
>__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern void *realloc (void *__ptr, size_t __size)
>__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>extern void free (void *__ptr) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern void cfree (void *__ptr) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern void *memalign (size_t __alignment, size_t __size)
>__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
>
>extern void *valloc (size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
>
>
>extern void *pvalloc (size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
>
>
>extern void *(*__morecore) (ptrdiff_t __size);
>
>
>extern void *__default_morecore (ptrdiff_t __size)
>__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__));
>
>
>
>struct mallinfo
>{
>  int arena;
>  int ordblks;
>  int smblks;
>  int hblks;
>  int hblkhd;
>  int usmblks;
>  int fsmblks;
>  int uordblks;
>  int fordblks;
>  int keepcost;
>};
>
>
>extern struct mallinfo mallinfo (void) __attribute__ ((__nothrow__ , __leaf__));
># 121 "/usr/include/malloc.h" 3 4
>extern int mallopt (int __param, int __val) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int malloc_trim (size_t __pad) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern size_t malloc_usable_size (void *__ptr) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern void malloc_stats (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int malloc_info (int __options, FILE *__fp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern void *malloc_get_state (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int malloc_set_state (void *__ptr) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern void (*volatile __malloc_initialize_hook) (void)
>__attribute__ ((__deprecated__));
>
>extern void (*volatile __free_hook) (void *__ptr,
>                                                   const void *)
>__attribute__ ((__deprecated__));
>extern void *(*volatile __malloc_hook)(size_t __size,
>                                                     const void *)
>__attribute__ ((__deprecated__));
>extern void *(*volatile __realloc_hook)(void *__ptr,
>                                                      size_t __size,
>                                                      const void *)
>__attribute__ ((__deprecated__));
>extern void *(*volatile __memalign_hook)(size_t __alignment,
>                                                       size_t __size,
>                                                       const void *)
>__attribute__ ((__deprecated__));
>extern void (*volatile __after_morecore_hook) (void);
>
>
>extern void __malloc_check_init (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__deprecated__));
>
>
>
># 178 "hstdinc.h" 2
>
>
># 1 "/usr/include/math.h" 1 3 4
># 28 "/usr/include/math.h" 3 4
>
>
>
>
># 1 "/usr/include/bits/huge_val.h" 1 3 4
># 33 "/usr/include/math.h" 2 3 4
>
># 1 "/usr/include/bits/huge_valf.h" 1 3 4
># 35 "/usr/include/math.h" 2 3 4
># 1 "/usr/include/bits/huge_vall.h" 1 3 4
># 36 "/usr/include/math.h" 2 3 4
>
>
># 1 "/usr/include/bits/inf.h" 1 3 4
># 39 "/usr/include/math.h" 2 3 4
>
>
># 1 "/usr/include/bits/nan.h" 1 3 4
># 42 "/usr/include/math.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/mathdef.h" 1 3 4
># 35 "/usr/include/bits/mathdef.h" 3 4
>typedef long double float_t;
>
>typedef long double double_t;
># 46 "/usr/include/math.h" 2 3 4
># 69 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 52 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern double acos (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __acos (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern double asin (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __asin (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern double atan (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __atan (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern double atan2 (double __y, double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __atan2 (double __y, double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double cos (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __cos (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern double sin (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __sin (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern double tan (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __tan (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern double cosh (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __cosh (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern double sinh (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __sinh (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern double tanh (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __tanh (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern void sincos (double __x, double *__sinx, double *__cosx) __attribute__ ((__nothrow__ , __leaf__)); extern void __sincos (double __x, double *__sinx, double *__cosx) __attribute__ ((__nothrow__ , __leaf__))
>                                                           ;
>
>
>
>
>
>extern double acosh (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __acosh (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern double asinh (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __asinh (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern double atanh (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __atanh (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern double exp (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __exp (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double frexp (double __x, int *__exponent) __attribute__ ((__nothrow__ , __leaf__)); extern double __frexp (double __x, int *__exponent) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double ldexp (double __x, int __exponent) __attribute__ ((__nothrow__ , __leaf__)); extern double __ldexp (double __x, int __exponent) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double log (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __log (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double log10 (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __log10 (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double modf (double __x, double *__iptr) __attribute__ ((__nothrow__ , __leaf__)); extern double __modf (double __x, double *__iptr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern double exp10 (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __exp10 (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern double pow10 (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __pow10 (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern double expm1 (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __expm1 (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double log1p (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __log1p (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double logb (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __logb (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern double exp2 (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __exp2 (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double log2 (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __log2 (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern double pow (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)); extern double __pow (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double sqrt (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __sqrt (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern double hypot (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)); extern double __hypot (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern double cbrt (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __cbrt (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern double ceil (double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern double __ceil (double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern double fabs (double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern double __fabs (double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern double floor (double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern double __floor (double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern double fmod (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)); extern double __fmod (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int __isinf (double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern int __finite (double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>
>extern int isinf (double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern int finite (double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern double drem (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)); extern double __drem (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern double significand (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __significand (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern double copysign (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern double __copysign (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>
>
>extern double nan (const char *__tagb) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern double __nan (const char *__tagb) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnan (double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern int isnan (double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern double j0 (double) __attribute__ ((__nothrow__ , __leaf__)); extern double __j0 (double) __attribute__ ((__nothrow__ , __leaf__));
>extern double j1 (double) __attribute__ ((__nothrow__ , __leaf__)); extern double __j1 (double) __attribute__ ((__nothrow__ , __leaf__));
>extern double jn (int, double) __attribute__ ((__nothrow__ , __leaf__)); extern double __jn (int, double) __attribute__ ((__nothrow__ , __leaf__));
>extern double y0 (double) __attribute__ ((__nothrow__ , __leaf__)); extern double __y0 (double) __attribute__ ((__nothrow__ , __leaf__));
>extern double y1 (double) __attribute__ ((__nothrow__ , __leaf__)); extern double __y1 (double) __attribute__ ((__nothrow__ , __leaf__));
>extern double yn (int, double) __attribute__ ((__nothrow__ , __leaf__)); extern double __yn (int, double) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern double erf (double) __attribute__ ((__nothrow__ , __leaf__)); extern double __erf (double) __attribute__ ((__nothrow__ , __leaf__));
>extern double erfc (double) __attribute__ ((__nothrow__ , __leaf__)); extern double __erfc (double) __attribute__ ((__nothrow__ , __leaf__));
>extern double lgamma (double) __attribute__ ((__nothrow__ , __leaf__)); extern double __lgamma (double) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern double tgamma (double) __attribute__ ((__nothrow__ , __leaf__)); extern double __tgamma (double) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern double gamma (double) __attribute__ ((__nothrow__ , __leaf__)); extern double __gamma (double) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern double lgamma_r (double, int *__signgamp) __attribute__ ((__nothrow__ , __leaf__)); extern double __lgamma_r (double, int *__signgamp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern double rint (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __rint (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double nextafter (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>extern double nexttoward (double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern double remainder (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)); extern double __remainder (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern double scalbn (double __x, int __n) __attribute__ ((__nothrow__ , __leaf__)); extern double __scalbn (double __x, int __n) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int ilogb (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern int __ilogb (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern double scalbln (double __x, long int __n) __attribute__ ((__nothrow__ , __leaf__)); extern double __scalbln (double __x, long int __n) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern double nearbyint (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern double __nearbyint (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern double round (double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern double __round (double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern double trunc (double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern double __trunc (double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>extern double remquo (double __x, double __y, int *__quo) __attribute__ ((__nothrow__ , __leaf__)); extern double __remquo (double __x, double __y, int *__quo) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern long int lrint (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long int __lrint (double __x) __attribute__ ((__nothrow__ , __leaf__));
>__extension__
>extern long long int llrint (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long long int __llrint (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern long int lround (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long int __lround (double __x) __attribute__ ((__nothrow__ , __leaf__));
>__extension__
>extern long long int llround (double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long long int __llround (double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern double fdim (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)); extern double __fdim (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern double fmax (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern double __fmax (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern double fmin (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern double __fmin (double __x, double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern int __fpclassify (double __value) __attribute__ ((__nothrow__ , __leaf__))
>     __attribute__ ((__const__));
>
>
>extern int __signbit (double __value) __attribute__ ((__nothrow__ , __leaf__))
>     __attribute__ ((__const__));
>
>
>
>extern double fma (double __x, double __y, double __z) __attribute__ ((__nothrow__ , __leaf__)); extern double __fma (double __x, double __y, double __z) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern int __issignaling (double __value) __attribute__ ((__nothrow__ , __leaf__))
>     __attribute__ ((__const__));
>
>
>
>
>extern double scalb (double __x, double __n) __attribute__ ((__nothrow__ , __leaf__)); extern double __scalb (double __x, double __n) __attribute__ ((__nothrow__ , __leaf__));
># 70 "/usr/include/math.h" 2 3 4
># 88 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 52 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern float acosf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __acosf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern float asinf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __asinf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern float atanf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __atanf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern float atan2f (float __y, float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __atan2f (float __y, float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float cosf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __cosf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern float sinf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __sinf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern float tanf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __tanf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern float coshf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __coshf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern float sinhf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __sinhf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern float tanhf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __tanhf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern void sincosf (float __x, float *__sinx, float *__cosx) __attribute__ ((__nothrow__ , __leaf__)); extern void __sincosf (float __x, float *__sinx, float *__cosx) __attribute__ ((__nothrow__ , __leaf__))
>                                                           ;
>
>
>
>
>
>extern float acoshf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __acoshf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern float asinhf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __asinhf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern float atanhf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __atanhf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern float expf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __expf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float frexpf (float __x, int *__exponent) __attribute__ ((__nothrow__ , __leaf__)); extern float __frexpf (float __x, int *__exponent) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float ldexpf (float __x, int __exponent) __attribute__ ((__nothrow__ , __leaf__)); extern float __ldexpf (float __x, int __exponent) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float logf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __logf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float log10f (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __log10f (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float modff (float __x, float *__iptr) __attribute__ ((__nothrow__ , __leaf__)); extern float __modff (float __x, float *__iptr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern float exp10f (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __exp10f (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern float pow10f (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __pow10f (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern float expm1f (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __expm1f (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float log1pf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __log1pf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float logbf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __logbf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern float exp2f (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __exp2f (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float log2f (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __log2f (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern float powf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)); extern float __powf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float sqrtf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __sqrtf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern float hypotf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)); extern float __hypotf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern float cbrtf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __cbrtf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern float ceilf (float __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern float __ceilf (float __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern float fabsf (float __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern float __fabsf (float __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern float floorf (float __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern float __floorf (float __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern float fmodf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)); extern float __fmodf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int __isinff (float __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern int __finitef (float __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>
>extern int isinff (float __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern int finitef (float __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern float dremf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)); extern float __dremf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern float significandf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __significandf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern float copysignf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>
>
>extern float nanf (const char *__tagb) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern float __nanf (const char *__tagb) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnanf (float __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern int isnanf (float __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern float j0f (float) __attribute__ ((__nothrow__ , __leaf__)); extern float __j0f (float) __attribute__ ((__nothrow__ , __leaf__));
>extern float j1f (float) __attribute__ ((__nothrow__ , __leaf__)); extern float __j1f (float) __attribute__ ((__nothrow__ , __leaf__));
>extern float jnf (int, float) __attribute__ ((__nothrow__ , __leaf__)); extern float __jnf (int, float) __attribute__ ((__nothrow__ , __leaf__));
>extern float y0f (float) __attribute__ ((__nothrow__ , __leaf__)); extern float __y0f (float) __attribute__ ((__nothrow__ , __leaf__));
>extern float y1f (float) __attribute__ ((__nothrow__ , __leaf__)); extern float __y1f (float) __attribute__ ((__nothrow__ , __leaf__));
>extern float ynf (int, float) __attribute__ ((__nothrow__ , __leaf__)); extern float __ynf (int, float) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern float erff (float) __attribute__ ((__nothrow__ , __leaf__)); extern float __erff (float) __attribute__ ((__nothrow__ , __leaf__));
>extern float erfcf (float) __attribute__ ((__nothrow__ , __leaf__)); extern float __erfcf (float) __attribute__ ((__nothrow__ , __leaf__));
>extern float lgammaf (float) __attribute__ ((__nothrow__ , __leaf__)); extern float __lgammaf (float) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern float tgammaf (float) __attribute__ ((__nothrow__ , __leaf__)); extern float __tgammaf (float) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern float gammaf (float) __attribute__ ((__nothrow__ , __leaf__)); extern float __gammaf (float) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern float lgammaf_r (float, int *__signgamp) __attribute__ ((__nothrow__ , __leaf__)); extern float __lgammaf_r (float, int *__signgamp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern float rintf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __rintf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float nextafterf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>extern float nexttowardf (float __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern float remainderf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)); extern float __remainderf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern float scalbnf (float __x, int __n) __attribute__ ((__nothrow__ , __leaf__)); extern float __scalbnf (float __x, int __n) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int ilogbf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern int __ilogbf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern float scalblnf (float __x, long int __n) __attribute__ ((__nothrow__ , __leaf__)); extern float __scalblnf (float __x, long int __n) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern float nearbyintf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern float __nearbyintf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern float roundf (float __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern float __roundf (float __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern float truncf (float __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern float __truncf (float __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>extern float remquof (float __x, float __y, int *__quo) __attribute__ ((__nothrow__ , __leaf__)); extern float __remquof (float __x, float __y, int *__quo) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern long int lrintf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern long int __lrintf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>__extension__
>extern long long int llrintf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern long long int __llrintf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern long int lroundf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern long int __lroundf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>__extension__
>extern long long int llroundf (float __x) __attribute__ ((__nothrow__ , __leaf__)); extern long long int __llroundf (float __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern float fdimf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)); extern float __fdimf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern float fmaxf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern float fminf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern float __fminf (float __x, float __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern int __fpclassifyf (float __value) __attribute__ ((__nothrow__ , __leaf__))
>     __attribute__ ((__const__));
>
>
>extern int __signbitf (float __value) __attribute__ ((__nothrow__ , __leaf__))
>     __attribute__ ((__const__));
>
>
>
>extern float fmaf (float __x, float __y, float __z) __attribute__ ((__nothrow__ , __leaf__)); extern float __fmaf (float __x, float __y, float __z) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern int __issignalingf (float __value) __attribute__ ((__nothrow__ , __leaf__))
>     __attribute__ ((__const__));
>
>
>
>
>extern float scalbf (float __x, float __n) __attribute__ ((__nothrow__ , __leaf__)); extern float __scalbf (float __x, float __n) __attribute__ ((__nothrow__ , __leaf__));
># 89 "/usr/include/math.h" 2 3 4
># 132 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 52 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern long double acosl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __acosl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern long double asinl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __asinl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern long double atanl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __atanl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern long double atan2l (long double __y, long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __atan2l (long double __y, long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double cosl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __cosl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern long double sinl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __sinl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern long double tanl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __tanl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern long double coshl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __coshl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern long double sinhl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __sinhl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern long double tanhl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __tanhl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern void sincosl (long double __x, long double *__sinx, long double *__cosx) __attribute__ ((__nothrow__ , __leaf__)); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) __attribute__ ((__nothrow__ , __leaf__))
>                                                           ;
>
>
>
>
>
>extern long double acoshl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __acoshl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern long double asinhl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __asinhl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern long double atanhl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __atanhl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern long double expl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __expl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double frexpl (long double __x, int *__exponent) __attribute__ ((__nothrow__ , __leaf__)); extern long double __frexpl (long double __x, int *__exponent) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double ldexpl (long double __x, int __exponent) __attribute__ ((__nothrow__ , __leaf__)); extern long double __ldexpl (long double __x, int __exponent) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double logl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __logl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double log10l (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __log10l (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double modfl (long double __x, long double *__iptr) __attribute__ ((__nothrow__ , __leaf__)); extern long double __modfl (long double __x, long double *__iptr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern long double exp10l (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __exp10l (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>extern long double pow10l (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __pow10l (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern long double expm1l (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __expm1l (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double log1pl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __log1pl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double logbl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __logbl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern long double exp2l (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __exp2l (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double log2l (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __log2l (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern long double powl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)); extern long double __powl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double sqrtl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __sqrtl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern long double hypotl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)); extern long double __hypotl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern long double cbrtl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __cbrtl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern long double ceill (long double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern long double __ceill (long double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern long double fabsl (long double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern long double __fabsl (long double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern long double floorl (long double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern long double __floorl (long double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern long double fmodl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)); extern long double __fmodl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int __isinfl (long double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern int __finitel (long double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>
>extern int isinfl (long double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern int finitel (long double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern long double dreml (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)); extern long double __dreml (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern long double significandl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __significandl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern long double copysignl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>
>
>extern long double nanl (const char *__tagb) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern long double __nanl (const char *__tagb) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnanl (long double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern int isnanl (long double __value) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern long double j0l (long double) __attribute__ ((__nothrow__ , __leaf__)); extern long double __j0l (long double) __attribute__ ((__nothrow__ , __leaf__));
>extern long double j1l (long double) __attribute__ ((__nothrow__ , __leaf__)); extern long double __j1l (long double) __attribute__ ((__nothrow__ , __leaf__));
>extern long double jnl (int, long double) __attribute__ ((__nothrow__ , __leaf__)); extern long double __jnl (int, long double) __attribute__ ((__nothrow__ , __leaf__));
>extern long double y0l (long double) __attribute__ ((__nothrow__ , __leaf__)); extern long double __y0l (long double) __attribute__ ((__nothrow__ , __leaf__));
>extern long double y1l (long double) __attribute__ ((__nothrow__ , __leaf__)); extern long double __y1l (long double) __attribute__ ((__nothrow__ , __leaf__));
>extern long double ynl (int, long double) __attribute__ ((__nothrow__ , __leaf__)); extern long double __ynl (int, long double) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern long double erfl (long double) __attribute__ ((__nothrow__ , __leaf__)); extern long double __erfl (long double) __attribute__ ((__nothrow__ , __leaf__));
>extern long double erfcl (long double) __attribute__ ((__nothrow__ , __leaf__)); extern long double __erfcl (long double) __attribute__ ((__nothrow__ , __leaf__));
>extern long double lgammal (long double) __attribute__ ((__nothrow__ , __leaf__)); extern long double __lgammal (long double) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern long double tgammal (long double) __attribute__ ((__nothrow__ , __leaf__)); extern long double __tgammal (long double) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern long double gammal (long double) __attribute__ ((__nothrow__ , __leaf__)); extern long double __gammal (long double) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern long double lgammal_r (long double, int *__signgamp) __attribute__ ((__nothrow__ , __leaf__)); extern long double __lgammal_r (long double, int *__signgamp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern long double rintl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __rintl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double nextafterl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>extern long double nexttowardl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern long double remainderl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)); extern long double __remainderl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern long double scalbnl (long double __x, int __n) __attribute__ ((__nothrow__ , __leaf__)); extern long double __scalbnl (long double __x, int __n) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int ilogbl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern int __ilogbl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern long double scalblnl (long double __x, long int __n) __attribute__ ((__nothrow__ , __leaf__)); extern long double __scalblnl (long double __x, long int __n) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern long double nearbyintl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long double __nearbyintl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern long double roundl (long double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern long double __roundl (long double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern long double truncl (long double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern long double __truncl (long double __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>extern long double remquol (long double __x, long double __y, int *__quo) __attribute__ ((__nothrow__ , __leaf__)); extern long double __remquol (long double __x, long double __y, int *__quo) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern long int lrintl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long int __lrintl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>__extension__
>extern long long int llrintl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long long int __llrintl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern long int lroundl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long int __lroundl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>__extension__
>extern long long int llroundl (long double __x) __attribute__ ((__nothrow__ , __leaf__)); extern long long int __llroundl (long double __x) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern long double fdiml (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)); extern long double __fdiml (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long double fmaxl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern long double fminl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>extern int __fpclassifyl (long double __value) __attribute__ ((__nothrow__ , __leaf__))
>     __attribute__ ((__const__));
>
>
>extern int __signbitl (long double __value) __attribute__ ((__nothrow__ , __leaf__))
>     __attribute__ ((__const__));
>
>
>
>extern long double fmal (long double __x, long double __y, long double __z) __attribute__ ((__nothrow__ , __leaf__)); extern long double __fmal (long double __x, long double __y, long double __z) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>extern int __issignalingl (long double __value) __attribute__ ((__nothrow__ , __leaf__))
>     __attribute__ ((__const__));
>
>
>
>
>extern long double scalbl (long double __x, long double __n) __attribute__ ((__nothrow__ , __leaf__)); extern long double __scalbl (long double __x, long double __n) __attribute__ ((__nothrow__ , __leaf__));
># 133 "/usr/include/math.h" 2 3 4
># 148 "/usr/include/math.h" 3 4
>extern int signgam;
># 189 "/usr/include/math.h" 3 4
>enum
>  {
>    FP_NAN =
>
>      0,
>    FP_INFINITE =
>
>      1,
>    FP_ZERO =
>
>      2,
>    FP_SUBNORMAL =
>
>      3,
>    FP_NORMAL =
>
>      4
>  };
># 301 "/usr/include/math.h" 3 4
>typedef enum
>{
>  _IEEE_ = -1,
>  _SVID_,
>  _XOPEN_,
>  _POSIX_,
>  _ISOC_
>} _LIB_VERSION_TYPE;
>
>
>
>
>extern _LIB_VERSION_TYPE _LIB_VERSION;
># 326 "/usr/include/math.h" 3 4
>struct exception
>
>  {
>    int type;
>    char *name;
>    double arg1;
>    double arg2;
>    double retval;
>  };
>
>
>
>
>extern int matherr (struct exception *__exc);
># 426 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathinline.h" 1 3 4
># 123 "/usr/include/bits/mathinline.h" 3 4
>
>
>
>extern __inline __attribute__ ((__always_inline__)) int
>__attribute__ ((__nothrow__ , __leaf__)) __signbitf (float __x)
>{
>
>
>
>
>
>  __extension__ union { float __f; int __i; } __u = { __f: __x };
>  return __u.__i < 0;
>
>}
>extern __inline __attribute__ ((__always_inline__)) int
>__attribute__ ((__nothrow__ , __leaf__)) __signbit (double __x)
>{
>
>
>
>
>
>  __extension__ union { double __d; int __i[2]; } __u = { __d: __x };
>  return __u.__i[1] < 0;
>
>}
>extern __inline __attribute__ ((__always_inline__)) int
>__attribute__ ((__nothrow__ , __leaf__)) __signbitl (long double __x)
>{
>  __extension__ union { long double __l; int __i[3]; } __u = { __l: __x };
>  return (__u.__i[2] & 0x8000) != 0;
>}
>
>
># 649 "/usr/include/bits/mathinline.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) long double __attribute__ ((__nothrow__ , __leaf__)) __atan2l (long double __y, long double __x) { return __builtin_atan2l (__y, __x); }
># 689 "/usr/include/bits/mathinline.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) double __attribute__ ((__nothrow__ , __leaf__)) fabs (double __x) { return __builtin_fabs (__x); }
>
>extern __inline __attribute__ ((__always_inline__)) float __attribute__ ((__nothrow__ , __leaf__)) fabsf (float __x) { return __builtin_fabsf (__x); }
>extern __inline __attribute__ ((__always_inline__)) long double __attribute__ ((__nothrow__ , __leaf__)) fabsl (long double __x) { return __builtin_fabsl (__x); }
>
>extern __inline __attribute__ ((__always_inline__)) long double __attribute__ ((__nothrow__ , __leaf__)) __fabsl (long double __x) { return __builtin_fabsl (__x); }
># 722 "/usr/include/bits/mathinline.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) long double __sgn1l (long double) __attribute__ ((__nothrow__ , __leaf__)); extern __inline __attribute__ ((__always_inline__)) long double __attribute__ ((__nothrow__ , __leaf__)) __sgn1l (long double __x) { __extension__ union { long double __xld; unsigned int __xi[3]; } __n = { __xld: __x }; __n.__xi[2] = (__n.__xi[2] & 0x8000) | 0x3fff; __n.__xi[1] = 0x80000000; __n.__xi[0] = 0; return __n.__xld; }
># 746 "/usr/include/bits/mathinline.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) double __attribute__ ((__nothrow__ , __leaf__)) floor (double __x) { register long double __value; register int __ignore; unsigned short int __cw; unsigned short int __cwtmp; __asm __volatile ("fnstcw %3\n\t" "movzwl %3, %1\n\t" "andl $0xf3ff, %1\n\t" "orl $0x0400, %1\n\t" "movw %w1, %2\n\t" "fldcw %2\n\t" "frndint\n\t" "fldcw %3" : "=t" (__value), "=&q" (__ignore), "=m" (__cwtmp), "=m" (__cw) : "0" (__x)); return __value; } extern __inline __attribute__ ((__always_inline__)) float __attribute__ ((__nothrow__ , __leaf__)) floorf (float __x) { register long double __value; register int __ignore; unsigned short int __cw; unsigned short int __cwtmp; __asm __volatile ("fnstcw %3\n\t" "movzwl %3, %1\n\t" "andl $0xf3ff, %1\n\t" "orl $0x0400, %1\n\t" "movw %w1, %2\n\t" "fldcw %2\n\t" "frndint\n\t" "fldcw %3" : "=t" (__value), "=&q" (__ignore), "=m" (__cwtmp), "=m" (__cw) : "0" (__x)); return __value; } extern __inline __attribute__ ((__always_inline__)) long double __attribute__ ((__nothrow__ , __leaf__)) floorl (long double __x) { register long double __value; register int __ignore; unsigned short int __cw; unsigned short int __cwtmp; __asm __volatile ("fnstcw %3\n\t" "movzwl %3, %1\n\t" "andl $0xf3ff, %1\n\t" "orl $0x0400, %1\n\t" "movw %w1, %2\n\t" "fldcw %2\n\t" "frndint\n\t" "fldcw %3" : "=t" (__value), "=&q" (__ignore), "=m" (__cwtmp), "=m" (__cw) : "0" (__x)); return __value; }
># 764 "/usr/include/bits/mathinline.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) double __attribute__ ((__nothrow__ , __leaf__)) ceil (double __x) { register long double __value; register int __ignore; unsigned short int __cw; unsigned short int __cwtmp; __asm __volatile ("fnstcw %3\n\t" "movzwl %3, %1\n\t" "andl $0xf3ff, %1\n\t" "orl $0x0800, %1\n\t" "movw %w1, %2\n\t" "fldcw %2\n\t" "frndint\n\t" "fldcw %3" : "=t" (__value), "=&q" (__ignore), "=m" (__cwtmp), "=m" (__cw) : "0" (__x)); return __value; } extern __inline __attribute__ ((__always_inline__)) float __attribute__ ((__nothrow__ , __leaf__)) ceilf (float __x) { register long double __value; register int __ignore; unsigned short int __cw; unsigned short int __cwtmp; __asm __volatile ("fnstcw %3\n\t" "movzwl %3, %1\n\t" "andl $0xf3ff, %1\n\t" "orl $0x0800, %1\n\t" "movw %w1, %2\n\t" "fldcw %2\n\t" "frndint\n\t" "fldcw %3" : "=t" (__value), "=&q" (__ignore), "=m" (__cwtmp), "=m" (__cw) : "0" (__x)); return __value; } extern __inline __attribute__ ((__always_inline__)) long double __attribute__ ((__nothrow__ , __leaf__)) ceill (long double __x) { register long double __value; register int __ignore; unsigned short int __cw; unsigned short int __cwtmp; __asm __volatile ("fnstcw %3\n\t" "movzwl %3, %1\n\t" "andl $0xf3ff, %1\n\t" "orl $0x0800, %1\n\t" "movw %w1, %2\n\t" "fldcw %2\n\t" "frndint\n\t" "fldcw %3" : "=t" (__value), "=&q" (__ignore), "=m" (__cwtmp), "=m" (__cw) : "0" (__x)); return __value; }
># 881 "/usr/include/bits/mathinline.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) long int
>__attribute__ ((__nothrow__ , __leaf__)) lrintf (float __x)
>{
>  long int __lrintres; __asm__ __volatile__ ("fistpl %0" : "=m" (__lrintres) : "t" (__x) : "st"); return __lrintres;
>}
>extern __inline __attribute__ ((__always_inline__)) long int
>__attribute__ ((__nothrow__ , __leaf__)) lrint (double __x)
>{
>  long int __lrintres; __asm__ __volatile__ ("fistpl %0" : "=m" (__lrintres) : "t" (__x) : "st"); return __lrintres;
>}
>extern __inline __attribute__ ((__always_inline__)) long int
>__attribute__ ((__nothrow__ , __leaf__)) lrintl (long double __x)
>{
>  long int __lrintres; __asm__ __volatile__ ("fistpl %0" : "=m" (__lrintres) : "t" (__x) : "st"); return __lrintres;
>}
># 904 "/usr/include/bits/mathinline.h" 3 4
>__extension__
>extern __inline __attribute__ ((__always_inline__)) long long int
>__attribute__ ((__nothrow__ , __leaf__)) llrintf (float __x)
>{
>  long long int __llrintres; __asm__ __volatile__ ("fistpll %0" : "=m" (__llrintres) : "t" (__x) : "st"); return __llrintres;
>}
>__extension__
>extern __inline __attribute__ ((__always_inline__)) long long int
>__attribute__ ((__nothrow__ , __leaf__)) llrint (double __x)
>{
>  long long int __llrintres; __asm__ __volatile__ ("fistpll %0" : "=m" (__llrintres) : "t" (__x) : "st"); return __llrintres;
>}
>__extension__
>extern __inline __attribute__ ((__always_inline__)) long long int
>__attribute__ ((__nothrow__ , __leaf__)) llrintl (long double __x)
>{
>  long long int __llrintres; __asm__ __volatile__ ("fistpll %0" : "=m" (__llrintres) : "t" (__x) : "st"); return __llrintres;
>}
># 944 "/usr/include/bits/mathinline.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) int
>__attribute__ ((__nothrow__ , __leaf__)) __finite (double __x)
>{
>  return (__extension__
>   (((((union { double __d; int __i[2]; }) {__d: __x}).__i[1]
>      | 0x800fffffu) + 1) >> 31));
>}
># 427 "/usr/include/math.h" 2 3 4
># 488 "/usr/include/math.h" 3 4
>
># 181 "hstdinc.h" 2
>
>
># 1 "/usr/include/netdb.h" 1 3 4
># 32 "/usr/include/netdb.h" 3 4
># 1 "/usr/include/rpc/netdb.h" 1 3 4
># 42 "/usr/include/rpc/netdb.h" 3 4
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 43 "/usr/include/rpc/netdb.h" 2 3 4
>
>
>
>struct rpcent
>{
>  char *r_name;
>  char **r_aliases;
>  int r_number;
>};
>
>extern void setrpcent (int __stayopen) __attribute__ ((__nothrow__ , __leaf__));
>extern void endrpcent (void) __attribute__ ((__nothrow__ , __leaf__));
>extern struct rpcent *getrpcbyname (const char *__name) __attribute__ ((__nothrow__ , __leaf__));
>extern struct rpcent *getrpcbynumber (int __number) __attribute__ ((__nothrow__ , __leaf__));
>extern struct rpcent *getrpcent (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int getrpcbyname_r (const char *__name, struct rpcent *__result_buf,
>      char *__buffer, size_t __buflen,
>      struct rpcent **__result) __attribute__ ((__nothrow__ , __leaf__));
>
>extern int getrpcbynumber_r (int __number, struct rpcent *__result_buf,
>        char *__buffer, size_t __buflen,
>        struct rpcent **__result) __attribute__ ((__nothrow__ , __leaf__));
>
>extern int getrpcent_r (struct rpcent *__result_buf, char *__buffer,
>   size_t __buflen, struct rpcent **__result) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
># 33 "/usr/include/netdb.h" 2 3 4
>
>
>
>
># 1 "/usr/include/bits/siginfo.h" 1 3 4
># 24 "/usr/include/bits/siginfo.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 25 "/usr/include/bits/siginfo.h" 2 3 4
># 38 "/usr/include/netdb.h" 2 3 4
>
>
>
>
># 1 "/usr/include/bits/netdb.h" 1 3 4
># 26 "/usr/include/bits/netdb.h" 3 4
>struct netent
>{
>  char *n_name;
>  char **n_aliases;
>  int n_addrtype;
>  uint32_t n_net;
>};
># 43 "/usr/include/netdb.h" 2 3 4
># 53 "/usr/include/netdb.h" 3 4
>
>
>
>
>
>
>
>
>extern int *__h_errno_location (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
># 92 "/usr/include/netdb.h" 3 4
>extern void herror (const char *__str) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern const char *hstrerror (int __err_num) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>struct hostent
>{
>  char *h_name;
>  char **h_aliases;
>  int h_addrtype;
>  int h_length;
>  char **h_addr_list;
>
>
>
>};
>
>
>
>
>
>
>extern void sethostent (int __stay_open);
>
>
>
>
>
>extern void endhostent (void);
>
>
>
>
>
>
>extern struct hostent *gethostent (void);
>
>
>
>
>
>
>extern struct hostent *gethostbyaddr (const void *__addr, __socklen_t __len,
>          int __type);
>
>
>
>
>
>extern struct hostent *gethostbyname (const char *__name);
># 155 "/usr/include/netdb.h" 3 4
>extern struct hostent *gethostbyname2 (const char *__name, int __af);
># 167 "/usr/include/netdb.h" 3 4
>extern int gethostent_r (struct hostent *__restrict __result_buf,
>    char *__restrict __buf, size_t __buflen,
>    struct hostent **__restrict __result,
>    int *__restrict __h_errnop);
>
>extern int gethostbyaddr_r (const void *__restrict __addr, __socklen_t __len,
>       int __type,
>       struct hostent *__restrict __result_buf,
>       char *__restrict __buf, size_t __buflen,
>       struct hostent **__restrict __result,
>       int *__restrict __h_errnop);
>
>extern int gethostbyname_r (const char *__restrict __name,
>       struct hostent *__restrict __result_buf,
>       char *__restrict __buf, size_t __buflen,
>       struct hostent **__restrict __result,
>       int *__restrict __h_errnop);
>
>extern int gethostbyname2_r (const char *__restrict __name, int __af,
>        struct hostent *__restrict __result_buf,
>        char *__restrict __buf, size_t __buflen,
>        struct hostent **__restrict __result,
>        int *__restrict __h_errnop);
># 198 "/usr/include/netdb.h" 3 4
>extern void setnetent (int __stay_open);
>
>
>
>
>
>extern void endnetent (void);
>
>
>
>
>
>
>extern struct netent *getnetent (void);
>
>
>
>
>
>
>extern struct netent *getnetbyaddr (uint32_t __net, int __type);
>
>
>
>
>
>extern struct netent *getnetbyname (const char *__name);
># 237 "/usr/include/netdb.h" 3 4
>extern int getnetent_r (struct netent *__restrict __result_buf,
>   char *__restrict __buf, size_t __buflen,
>   struct netent **__restrict __result,
>   int *__restrict __h_errnop);
>
>extern int getnetbyaddr_r (uint32_t __net, int __type,
>      struct netent *__restrict __result_buf,
>      char *__restrict __buf, size_t __buflen,
>      struct netent **__restrict __result,
>      int *__restrict __h_errnop);
>
>extern int getnetbyname_r (const char *__restrict __name,
>      struct netent *__restrict __result_buf,
>      char *__restrict __buf, size_t __buflen,
>      struct netent **__restrict __result,
>      int *__restrict __h_errnop);
>
>
>
>
>struct servent
>{
>  char *s_name;
>  char **s_aliases;
>  int s_port;
>  char *s_proto;
>};
>
>
>
>
>
>
>extern void setservent (int __stay_open);
>
>
>
>
>
>extern void endservent (void);
>
>
>
>
>
>
>extern struct servent *getservent (void);
>
>
>
>
>
>
>extern struct servent *getservbyname (const char *__name, const char *__proto);
>
>
>
>
>
>
>extern struct servent *getservbyport (int __port, const char *__proto);
># 308 "/usr/include/netdb.h" 3 4
>extern int getservent_r (struct servent *__restrict __result_buf,
>    char *__restrict __buf, size_t __buflen,
>    struct servent **__restrict __result);
>
>extern int getservbyname_r (const char *__restrict __name,
>       const char *__restrict __proto,
>       struct servent *__restrict __result_buf,
>       char *__restrict __buf, size_t __buflen,
>       struct servent **__restrict __result);
>
>extern int getservbyport_r (int __port, const char *__restrict __proto,
>       struct servent *__restrict __result_buf,
>       char *__restrict __buf, size_t __buflen,
>       struct servent **__restrict __result);
>
>
>
>
>struct protoent
>{
>  char *p_name;
>  char **p_aliases;
>  int p_proto;
>};
>
>
>
>
>
>
>extern void setprotoent (int __stay_open);
>
>
>
>
>
>extern void endprotoent (void);
>
>
>
>
>
>
>extern struct protoent *getprotoent (void);
>
>
>
>
>
>extern struct protoent *getprotobyname (const char *__name);
>
>
>
>
>
>extern struct protoent *getprotobynumber (int __proto);
># 374 "/usr/include/netdb.h" 3 4
>extern int getprotoent_r (struct protoent *__restrict __result_buf,
>     char *__restrict __buf, size_t __buflen,
>     struct protoent **__restrict __result);
>
>extern int getprotobyname_r (const char *__restrict __name,
>        struct protoent *__restrict __result_buf,
>        char *__restrict __buf, size_t __buflen,
>        struct protoent **__restrict __result);
>
>extern int getprotobynumber_r (int __proto,
>          struct protoent *__restrict __result_buf,
>          char *__restrict __buf, size_t __buflen,
>          struct protoent **__restrict __result);
># 395 "/usr/include/netdb.h" 3 4
>extern int setnetgrent (const char *__netgroup);
>
>
>
>
>
>
>
>extern void endnetgrent (void);
># 412 "/usr/include/netdb.h" 3 4
>extern int getnetgrent (char **__restrict __hostp,
>   char **__restrict __userp,
>   char **__restrict __domainp);
># 423 "/usr/include/netdb.h" 3 4
>extern int innetgr (const char *__netgroup, const char *__host,
>      const char *__user, const char *__domain);
>
>
>
>
>
>
>
>extern int getnetgrent_r (char **__restrict __hostp,
>     char **__restrict __userp,
>     char **__restrict __domainp,
>     char *__restrict __buffer, size_t __buflen);
># 451 "/usr/include/netdb.h" 3 4
>extern int rcmd (char **__restrict __ahost, unsigned short int __rport,
>   const char *__restrict __locuser,
>   const char *__restrict __remuser,
>   const char *__restrict __cmd, int *__restrict __fd2p);
># 463 "/usr/include/netdb.h" 3 4
>extern int rcmd_af (char **__restrict __ahost, unsigned short int __rport,
>      const char *__restrict __locuser,
>      const char *__restrict __remuser,
>      const char *__restrict __cmd, int *__restrict __fd2p,
>      sa_family_t __af);
># 479 "/usr/include/netdb.h" 3 4
>extern int rexec (char **__restrict __ahost, int __rport,
>    const char *__restrict __name,
>    const char *__restrict __pass,
>    const char *__restrict __cmd, int *__restrict __fd2p);
># 491 "/usr/include/netdb.h" 3 4
>extern int rexec_af (char **__restrict __ahost, int __rport,
>       const char *__restrict __name,
>       const char *__restrict __pass,
>       const char *__restrict __cmd, int *__restrict __fd2p,
>       sa_family_t __af);
># 505 "/usr/include/netdb.h" 3 4
>extern int ruserok (const char *__rhost, int __suser,
>      const char *__remuser, const char *__locuser);
># 515 "/usr/include/netdb.h" 3 4
>extern int ruserok_af (const char *__rhost, int __suser,
>         const char *__remuser, const char *__locuser,
>         sa_family_t __af);
># 528 "/usr/include/netdb.h" 3 4
>extern int iruserok (uint32_t __raddr, int __suser,
>       const char *__remuser, const char *__locuser);
># 539 "/usr/include/netdb.h" 3 4
>extern int iruserok_af (const void *__raddr, int __suser,
>   const char *__remuser, const char *__locuser,
>   sa_family_t __af);
># 551 "/usr/include/netdb.h" 3 4
>extern int rresvport (int *__alport);
># 560 "/usr/include/netdb.h" 3 4
>extern int rresvport_af (int *__alport, sa_family_t __af);
>
>
>
>
>
>
>struct addrinfo
>{
>  int ai_flags;
>  int ai_family;
>  int ai_socktype;
>  int ai_protocol;
>  socklen_t ai_addrlen;
>  struct sockaddr *ai_addr;
>  char *ai_canonname;
>  struct addrinfo *ai_next;
>};
>
>
>
>struct gaicb
>{
>  const char *ar_name;
>  const char *ar_service;
>  const struct addrinfo *ar_request;
>  struct addrinfo *ar_result;
>
>  int __return;
>  int __glibc_reserved[5];
>};
># 662 "/usr/include/netdb.h" 3 4
>extern int getaddrinfo (const char *__restrict __name,
>   const char *__restrict __service,
>   const struct addrinfo *__restrict __req,
>   struct addrinfo **__restrict __pai);
>
>
>extern void freeaddrinfo (struct addrinfo *__ai) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern const char *gai_strerror (int __ecode) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int getnameinfo (const struct sockaddr *__restrict __sa,
>   socklen_t __salen, char *__restrict __host,
>   socklen_t __hostlen, char *__restrict __serv,
>   socklen_t __servlen, int __flags);
># 692 "/usr/include/netdb.h" 3 4
>extern int getaddrinfo_a (int __mode, struct gaicb *__list[__restrict],
>     int __ent, struct sigevent *__restrict __sig);
># 703 "/usr/include/netdb.h" 3 4
>extern int gai_suspend (const struct gaicb *const __list[], int __ent,
>   const struct timespec *__timeout);
>
>
>extern int gai_error (struct gaicb *__req) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int gai_cancel (struct gaicb *__gaicbp) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
># 184 "hstdinc.h" 2
>
>
># 1 "/usr/include/pwd.h" 1 3 4
># 27 "/usr/include/pwd.h" 3 4
>
>
>
>
>
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 33 "/usr/include/pwd.h" 2 3 4
># 49 "/usr/include/pwd.h" 3 4
>struct passwd
>{
>  char *pw_name;
>  char *pw_passwd;
>  __uid_t pw_uid;
>  __gid_t pw_gid;
>  char *pw_gecos;
>  char *pw_dir;
>  char *pw_shell;
>};
># 72 "/usr/include/pwd.h" 3 4
>extern void setpwent (void);
>
>
>
>
>
>extern void endpwent (void);
>
>
>
>
>
>extern struct passwd *getpwent (void);
># 94 "/usr/include/pwd.h" 3 4
>extern struct passwd *fgetpwent (FILE *__stream);
>
>
>
>
>
>
>
>extern int putpwent (const struct passwd *__restrict __p,
>       FILE *__restrict __f);
>
>
>
>
>
>
>extern struct passwd *getpwuid (__uid_t __uid);
>
>
>
>
>
>extern struct passwd *getpwnam (const char *__name);
># 139 "/usr/include/pwd.h" 3 4
>extern int getpwent_r (struct passwd *__restrict __resultbuf,
>         char *__restrict __buffer, size_t __buflen,
>         struct passwd **__restrict __result);
>
>
>extern int getpwuid_r (__uid_t __uid,
>         struct passwd *__restrict __resultbuf,
>         char *__restrict __buffer, size_t __buflen,
>         struct passwd **__restrict __result);
>
>extern int getpwnam_r (const char *__restrict __name,
>         struct passwd *__restrict __resultbuf,
>         char *__restrict __buffer, size_t __buflen,
>         struct passwd **__restrict __result);
># 163 "/usr/include/pwd.h" 3 4
>extern int fgetpwent_r (FILE *__restrict __stream,
>   struct passwd *__restrict __resultbuf,
>   char *__restrict __buffer, size_t __buflen,
>   struct passwd **__restrict __result);
># 180 "/usr/include/pwd.h" 3 4
>extern int getpw (__uid_t __uid, char *__buffer);
>
>
>
># 187 "hstdinc.h" 2
>
>
># 1 "/usr/include/regex.h" 1 3 4
># 34 "/usr/include/regex.h" 3 4
>typedef long int s_reg_t;
>typedef unsigned long int active_reg_t;
>
>
>
>
>
>
>typedef unsigned long int reg_syntax_t;
># 181 "/usr/include/regex.h" 3 4
>extern reg_syntax_t re_syntax_options;
># 308 "/usr/include/regex.h" 3 4
>typedef enum
>{
>
>  REG_ENOSYS = -1,
>
>
>  REG_NOERROR = 0,
>  REG_NOMATCH,
>
>
>
>  REG_BADPAT,
>  REG_ECOLLATE,
>  REG_ECTYPE,
>  REG_EESCAPE,
>  REG_ESUBREG,
>  REG_EBRACK,
>  REG_EPAREN,
>  REG_EBRACE,
>  REG_BADBR,
>  REG_ERANGE,
>  REG_ESPACE,
>  REG_BADRPT,
>
>
>  REG_EEND,
>  REG_ESIZE,
>  REG_ERPAREN
>} reg_errcode_t;
># 357 "/usr/include/regex.h" 3 4
>struct re_pattern_buffer
>{
>
>
>
>  unsigned char *buffer;
>
>
>  unsigned long int allocated;
>
>
>  unsigned long int used;
>
>
>  reg_syntax_t syntax;
>
>
>
>
>  char *fastmap;
>
>
>
>
>
>  unsigned char * translate;
>
>
>  size_t re_nsub;
>
>
>
>
>
>  unsigned can_be_null : 1;
># 402 "/usr/include/regex.h" 3 4
>  unsigned regs_allocated : 2;
>
>
>
>  unsigned fastmap_accurate : 1;
>
>
>
>  unsigned no_sub : 1;
>
>
>
>  unsigned not_bol : 1;
>
>
>  unsigned not_eol : 1;
>
>
>  unsigned newline_anchor : 1;
>};
>
>typedef struct re_pattern_buffer regex_t;
>
>
>typedef int regoff_t;
>
>
>
>
>
>struct re_registers
>{
>  unsigned num_regs;
>  regoff_t *start;
>  regoff_t *end;
>};
># 452 "/usr/include/regex.h" 3 4
>typedef struct
>{
>  regoff_t rm_so;
>  regoff_t rm_eo;
>} regmatch_t;
>
>
>
>
>
>
>extern reg_syntax_t re_set_syntax (reg_syntax_t __syntax);
># 473 "/usr/include/regex.h" 3 4
>extern const char *re_compile_pattern (const char *__pattern, size_t __length,
>           struct re_pattern_buffer *__buffer);
>
>
>
>
>
>extern int re_compile_fastmap (struct re_pattern_buffer *__buffer);
>
>
>
>
>
>
>
>extern int re_search (struct re_pattern_buffer *__buffer, const char *__string,
>        int __length, int __start, int __range,
>        struct re_registers *__regs);
>
>
>
>
>extern int re_search_2 (struct re_pattern_buffer *__buffer,
>   const char *__string1, int __length1,
>   const char *__string2, int __length2, int __start,
>   int __range, struct re_registers *__regs, int __stop);
>
>
>
>
>extern int re_match (struct re_pattern_buffer *__buffer, const char *__string,
>       int __length, int __start, struct re_registers *__regs);
>
>
>
>extern int re_match_2 (struct re_pattern_buffer *__buffer,
>         const char *__string1, int __length1,
>         const char *__string2, int __length2, int __start,
>         struct re_registers *__regs, int __stop);
># 526 "/usr/include/regex.h" 3 4
>extern void re_set_registers (struct re_pattern_buffer *__buffer,
>         struct re_registers *__regs,
>         unsigned int __num_regs,
>         regoff_t *__starts, regoff_t *__ends);
># 562 "/usr/include/regex.h" 3 4
>extern int regcomp (regex_t *__restrict __preg,
>      const char *__restrict __pattern,
>      int __cflags);
>
>extern int regexec (const regex_t *__restrict __preg,
>      const char *__restrict __string, size_t __nmatch,
>      regmatch_t __pmatch[__restrict],
>      int __eflags);
>
>extern size_t regerror (int __errcode, const regex_t *__restrict __preg,
>   char *__restrict __errbuf, size_t __errbuf_size);
>
>extern void regfree (regex_t *__preg);
># 190 "hstdinc.h" 2
>
>
># 1 "/usr/include/sched.h" 1 3 4
># 28 "/usr/include/sched.h" 3 4
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 29 "/usr/include/sched.h" 2 3 4
># 43 "/usr/include/sched.h" 3 4
># 1 "/usr/include/bits/sched.h" 1 3 4
># 72 "/usr/include/bits/sched.h" 3 4
>struct sched_param
>  {
>    int __sched_priority;
>  };
>
>
>
>
>
>extern int clone (int (*__fn) (void *__arg), void *__child_stack,
>    int __flags, void *__arg, ...) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int unshare (int __flags) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sched_getcpu (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int setns (int __fd, int __nstype) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>
>
>
>
>struct __sched_param
>  {
>    int __sched_priority;
>  };
># 118 "/usr/include/bits/sched.h" 3 4
>typedef unsigned long int __cpu_mask;
>
>
>
>
>
>
>typedef struct
>{
>  __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
>} cpu_set_t;
># 201 "/usr/include/bits/sched.h" 3 4
>
>
>extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
>  __attribute__ ((__nothrow__ , __leaf__));
>extern cpu_set_t *__sched_cpualloc (size_t __count) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>extern void __sched_cpufree (cpu_set_t *__set) __attribute__ ((__nothrow__ , __leaf__));
>
>
># 44 "/usr/include/sched.h" 2 3 4
>
>
>
>
>
>
>
>extern int sched_setparam (__pid_t __pid, const struct sched_param *__param)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sched_getparam (__pid_t __pid, struct sched_param *__param) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sched_setscheduler (__pid_t __pid, int __policy,
>          const struct sched_param *__param) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sched_getscheduler (__pid_t __pid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sched_yield (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sched_get_priority_max (int __algorithm) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sched_get_priority_min (int __algorithm) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) __attribute__ ((__nothrow__ , __leaf__));
># 118 "/usr/include/sched.h" 3 4
>extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
>         const cpu_set_t *__cpuset) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
>         cpu_set_t *__cpuset) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
># 193 "hstdinc.h" 2
># 201 "hstdinc.h"
># 1 "/usr/include/termios.h" 1 3 4
># 35 "/usr/include/termios.h" 3 4
>
>
>
>
># 1 "/usr/include/bits/termios.h" 1 3 4
># 23 "/usr/include/bits/termios.h" 3 4
>typedef unsigned char cc_t;
>typedef unsigned int speed_t;
>typedef unsigned int tcflag_t;
>
>
>struct termios
>  {
>    tcflag_t c_iflag;
>    tcflag_t c_oflag;
>    tcflag_t c_cflag;
>    tcflag_t c_lflag;
>    cc_t c_line;
>    cc_t c_cc[32];
>    speed_t c_ispeed;
>    speed_t c_ospeed;
>
>
>  };
># 40 "/usr/include/termios.h" 2 3 4
># 48 "/usr/include/termios.h" 3 4
>extern speed_t cfgetospeed (const struct termios *__termios_p) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern speed_t cfgetispeed (const struct termios *__termios_p) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int cfsetospeed (struct termios *__termios_p, speed_t __speed) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int cfsetispeed (struct termios *__termios_p, speed_t __speed) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int cfsetspeed (struct termios *__termios_p, speed_t __speed) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int tcgetattr (int __fd, struct termios *__termios_p) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int tcsetattr (int __fd, int __optional_actions,
>        const struct termios *__termios_p) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern void cfmakeraw (struct termios *__termios_p) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int tcsendbreak (int __fd, int __duration) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int tcdrain (int __fd);
>
>
>
>extern int tcflush (int __fd, int __queue_selector) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int tcflow (int __fd, int __action) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern __pid_t tcgetsid (int __fd) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
># 1 "/usr/include/sys/ttydefaults.h" 1 3 4
># 105 "/usr/include/termios.h" 2 3 4
>
>
>
># 202 "hstdinc.h" 2
>
>
># 1 "/usr/include/zlib.h" 1 3 4
># 34 "/usr/include/zlib.h" 3 4
># 1 "/usr/include/zconf.h" 1 3 4
># 368 "/usr/include/zconf.h" 3 4
>typedef unsigned char Byte;
>
>typedef unsigned int uInt;
>typedef unsigned long uLong;
>
>
>
>
>
>   typedef Byte Bytef;
>
>typedef char charf;
>typedef int intf;
>typedef uInt uIntf;
>typedef uLong uLongf;
>
>
>   typedef void const *voidpc;
>   typedef void *voidpf;
>   typedef void *voidp;
>
>
>
>
>
>
>
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/limits.h" 1 3 4
># 396 "/usr/include/zconf.h" 2 3 4
># 406 "/usr/include/zconf.h" 3 4
>   typedef unsigned z_crc_t;
># 452 "/usr/include/zconf.h" 3 4
># 1 "/usr/include/unistd.h" 1 3 4
># 27 "/usr/include/unistd.h" 3 4
>
># 202 "/usr/include/unistd.h" 3 4
># 1 "/usr/include/bits/posix_opt.h" 1 3 4
># 203 "/usr/include/unistd.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/environments.h" 1 3 4
># 22 "/usr/include/bits/environments.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 23 "/usr/include/bits/environments.h" 2 3 4
># 207 "/usr/include/unistd.h" 2 3 4
># 226 "/usr/include/unistd.h" 3 4
># 1 "/usr/lib/gcc/i686-redhat-linux/4.9.1/include/stddef.h" 1 3 4
># 227 "/usr/include/unistd.h" 2 3 4
># 287 "/usr/include/unistd.h" 3 4
>extern int access (const char *__name, int __type) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int euidaccess (const char *__name, int __type)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int eaccess (const char *__name, int __type)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int faccessat (int __fd, const char *__file, int __type, int __flag)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
># 337 "/usr/include/unistd.h" 3 4
>extern __off64_t lseek (int __fd, __off64_t __offset, int __whence) __asm__ ("" "lseek64") __attribute__ ((__nothrow__ , __leaf__))
>
>             ;
>
>
>
>
>
>extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int close (int __fd);
>
>
>
>
>
>
>extern ssize_t read (int __fd, void *__buf, size_t __nbytes) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern ssize_t write (int __fd, const void *__buf, size_t __n) __attribute__ ((__warn_unused_result__));
># 388 "/usr/include/unistd.h" 3 4
>extern ssize_t pread (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pread64")
>
>               __attribute__ ((__warn_unused_result__));
>extern ssize_t pwrite (int __fd, const void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pwrite64")
>
>                __attribute__ ((__warn_unused_result__));
># 404 "/usr/include/unistd.h" 3 4
>extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
>   __off64_t __offset) __attribute__ ((__warn_unused_result__));
>
>
>extern ssize_t pwrite64 (int __fd, const void *__buf, size_t __n,
>    __off64_t __offset) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>extern int pipe (int __pipedes[2]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int pipe2 (int __pipedes[2], int __flags) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
># 432 "/usr/include/unistd.h" 3 4
>extern unsigned int alarm (unsigned int __seconds) __attribute__ ((__nothrow__ , __leaf__));
># 444 "/usr/include/unistd.h" 3 4
>extern unsigned int sleep (unsigned int __seconds);
>
>
>
>
>
>
>
>extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int usleep (__useconds_t __useconds);
># 469 "/usr/include/unistd.h" 3 4
>extern int pause (void);
>
>
>
>extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>extern int fchown (int __fd, __uid_t __owner, __gid_t __group) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern int fchownat (int __fd, const char *__file, __uid_t __owner,
>       __gid_t __group, int __flag)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
>
>
>
>extern int chdir (const char *__path) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>extern int fchdir (int __fd) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
># 511 "/usr/include/unistd.h" 3 4
>extern char *getcwd (char *__buf, size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern char *get_current_dir_name (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern char *getwd (char *__buf)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int dup (int __fd) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>extern int dup2 (int __fd, int __fd2) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int dup3 (int __fd, int __fd2, int __flags) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern char **__environ;
>
>extern char **environ;
>
>
>
>
>
>extern int execve (const char *__path, char *const __argv[],
>     char *const __envp[]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int fexecve (int __fd, char *const __argv[], char *const __envp[])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern int execv (const char *__path, char *const __argv[])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int execle (const char *__path, const char *__arg, ...)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int execl (const char *__path, const char *__arg, ...)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int execvp (const char *__file, char *const __argv[])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int execlp (const char *__file, const char *__arg, ...)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int execvpe (const char *__file, char *const __argv[],
>      char *const __envp[])
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int nice (int __inc) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern void _exit (int __status) __attribute__ ((__noreturn__));
>
>
>
>
>
># 1 "/usr/include/bits/confname.h" 1 3 4
># 24 "/usr/include/bits/confname.h" 3 4
>enum
>  {
>    _PC_LINK_MAX,
>
>    _PC_MAX_CANON,
>
>    _PC_MAX_INPUT,
>
>    _PC_NAME_MAX,
>
>    _PC_PATH_MAX,
>
>    _PC_PIPE_BUF,
>
>    _PC_CHOWN_RESTRICTED,
>
>    _PC_NO_TRUNC,
>
>    _PC_VDISABLE,
>
>    _PC_SYNC_IO,
>
>    _PC_ASYNC_IO,
>
>    _PC_PRIO_IO,
>
>    _PC_SOCK_MAXBUF,
>
>    _PC_FILESIZEBITS,
>
>    _PC_REC_INCR_XFER_SIZE,
>
>    _PC_REC_MAX_XFER_SIZE,
>
>    _PC_REC_MIN_XFER_SIZE,
>
>    _PC_REC_XFER_ALIGN,
>
>    _PC_ALLOC_SIZE_MIN,
>
>    _PC_SYMLINK_MAX,
>
>    _PC_2_SYMLINKS
>
>  };
>
>
>enum
>  {
>    _SC_ARG_MAX,
>
>    _SC_CHILD_MAX,
>
>    _SC_CLK_TCK,
>
>    _SC_NGROUPS_MAX,
>
>    _SC_OPEN_MAX,
>
>    _SC_STREAM_MAX,
>
>    _SC_TZNAME_MAX,
>
>    _SC_JOB_CONTROL,
>
>    _SC_SAVED_IDS,
>
>    _SC_REALTIME_SIGNALS,
>
>    _SC_PRIORITY_SCHEDULING,
>
>    _SC_TIMERS,
>
>    _SC_ASYNCHRONOUS_IO,
>
>    _SC_PRIORITIZED_IO,
>
>    _SC_SYNCHRONIZED_IO,
>
>    _SC_FSYNC,
>
>    _SC_MAPPED_FILES,
>
>    _SC_MEMLOCK,
>
>    _SC_MEMLOCK_RANGE,
>
>    _SC_MEMORY_PROTECTION,
>
>    _SC_MESSAGE_PASSING,
>
>    _SC_SEMAPHORES,
>
>    _SC_SHARED_MEMORY_OBJECTS,
>
>    _SC_AIO_LISTIO_MAX,
>
>    _SC_AIO_MAX,
>
>    _SC_AIO_PRIO_DELTA_MAX,
>
>    _SC_DELAYTIMER_MAX,
>
>    _SC_MQ_OPEN_MAX,
>
>    _SC_MQ_PRIO_MAX,
>
>    _SC_VERSION,
>
>    _SC_PAGESIZE,
>
>
>    _SC_RTSIG_MAX,
>
>    _SC_SEM_NSEMS_MAX,
>
>    _SC_SEM_VALUE_MAX,
>
>    _SC_SIGQUEUE_MAX,
>
>    _SC_TIMER_MAX,
>
>
>
>
>    _SC_BC_BASE_MAX,
>
>    _SC_BC_DIM_MAX,
>
>    _SC_BC_SCALE_MAX,
>
>    _SC_BC_STRING_MAX,
>
>    _SC_COLL_WEIGHTS_MAX,
>
>    _SC_EQUIV_CLASS_MAX,
>
>    _SC_EXPR_NEST_MAX,
>
>    _SC_LINE_MAX,
>
>    _SC_RE_DUP_MAX,
>
>    _SC_CHARCLASS_NAME_MAX,
>
>
>    _SC_2_VERSION,
>
>    _SC_2_C_BIND,
>
>    _SC_2_C_DEV,
>
>    _SC_2_FORT_DEV,
>
>    _SC_2_FORT_RUN,
>
>    _SC_2_SW_DEV,
>
>    _SC_2_LOCALEDEF,
>
>
>    _SC_PII,
>
>    _SC_PII_XTI,
>
>    _SC_PII_SOCKET,
>
>    _SC_PII_INTERNET,
>
>    _SC_PII_OSI,
>
>    _SC_POLL,
>
>    _SC_SELECT,
>
>    _SC_UIO_MAXIOV,
>
>    _SC_IOV_MAX = _SC_UIO_MAXIOV,
>
>    _SC_PII_INTERNET_STREAM,
>
>    _SC_PII_INTERNET_DGRAM,
>
>    _SC_PII_OSI_COTS,
>
>    _SC_PII_OSI_CLTS,
>
>    _SC_PII_OSI_M,
>
>    _SC_T_IOV_MAX,
>
>
>
>    _SC_THREADS,
>
>    _SC_THREAD_SAFE_FUNCTIONS,
>
>    _SC_GETGR_R_SIZE_MAX,
>
>    _SC_GETPW_R_SIZE_MAX,
>
>    _SC_LOGIN_NAME_MAX,
>
>    _SC_TTY_NAME_MAX,
>
>    _SC_THREAD_DESTRUCTOR_ITERATIONS,
>
>    _SC_THREAD_KEYS_MAX,
>
>    _SC_THREAD_STACK_MIN,
>
>    _SC_THREAD_THREADS_MAX,
>
>    _SC_THREAD_ATTR_STACKADDR,
>
>    _SC_THREAD_ATTR_STACKSIZE,
>
>    _SC_THREAD_PRIORITY_SCHEDULING,
>
>    _SC_THREAD_PRIO_INHERIT,
>
>    _SC_THREAD_PRIO_PROTECT,
>
>    _SC_THREAD_PROCESS_SHARED,
>
>
>    _SC_NPROCESSORS_CONF,
>
>    _SC_NPROCESSORS_ONLN,
>
>    _SC_PHYS_PAGES,
>
>    _SC_AVPHYS_PAGES,
>
>    _SC_ATEXIT_MAX,
>
>    _SC_PASS_MAX,
>
>
>    _SC_XOPEN_VERSION,
>
>    _SC_XOPEN_XCU_VERSION,
>
>    _SC_XOPEN_UNIX,
>
>    _SC_XOPEN_CRYPT,
>
>    _SC_XOPEN_ENH_I18N,
>
>    _SC_XOPEN_SHM,
>
>
>    _SC_2_CHAR_TERM,
>
>    _SC_2_C_VERSION,
>
>    _SC_2_UPE,
>
>
>    _SC_XOPEN_XPG2,
>
>    _SC_XOPEN_XPG3,
>
>    _SC_XOPEN_XPG4,
>
>
>    _SC_CHAR_BIT,
>
>    _SC_CHAR_MAX,
>
>    _SC_CHAR_MIN,
>
>    _SC_INT_MAX,
>
>    _SC_INT_MIN,
>
>    _SC_LONG_BIT,
>
>    _SC_WORD_BIT,
>
>    _SC_MB_LEN_MAX,
>
>    _SC_NZERO,
>
>    _SC_SSIZE_MAX,
>
>    _SC_SCHAR_MAX,
>
>    _SC_SCHAR_MIN,
>
>    _SC_SHRT_MAX,
>
>    _SC_SHRT_MIN,
>
>    _SC_UCHAR_MAX,
>
>    _SC_UINT_MAX,
>
>    _SC_ULONG_MAX,
>
>    _SC_USHRT_MAX,
>
>
>    _SC_NL_ARGMAX,
>
>    _SC_NL_LANGMAX,
>
>    _SC_NL_MSGMAX,
>
>    _SC_NL_NMAX,
>
>    _SC_NL_SETMAX,
>
>    _SC_NL_TEXTMAX,
>
>
>    _SC_XBS5_ILP32_OFF32,
>
>    _SC_XBS5_ILP32_OFFBIG,
>
>    _SC_XBS5_LP64_OFF64,
>
>    _SC_XBS5_LPBIG_OFFBIG,
>
>
>    _SC_XOPEN_LEGACY,
>
>    _SC_XOPEN_REALTIME,
>
>    _SC_XOPEN_REALTIME_THREADS,
>
>
>    _SC_ADVISORY_INFO,
>
>    _SC_BARRIERS,
>
>    _SC_BASE,
>
>    _SC_C_LANG_SUPPORT,
>
>    _SC_C_LANG_SUPPORT_R,
>
>    _SC_CLOCK_SELECTION,
>
>    _SC_CPUTIME,
>
>    _SC_THREAD_CPUTIME,
>
>    _SC_DEVICE_IO,
>
>    _SC_DEVICE_SPECIFIC,
>
>    _SC_DEVICE_SPECIFIC_R,
>
>    _SC_FD_MGMT,
>
>    _SC_FIFO,
>
>    _SC_PIPE,
>
>    _SC_FILE_ATTRIBUTES,
>
>    _SC_FILE_LOCKING,
>
>    _SC_FILE_SYSTEM,
>
>    _SC_MONOTONIC_CLOCK,
>
>    _SC_MULTI_PROCESS,
>
>    _SC_SINGLE_PROCESS,
>
>    _SC_NETWORKING,
>
>    _SC_READER_WRITER_LOCKS,
>
>    _SC_SPIN_LOCKS,
>
>    _SC_REGEXP,
>
>    _SC_REGEX_VERSION,
>
>    _SC_SHELL,
>
>    _SC_SIGNALS,
>
>    _SC_SPAWN,
>
>    _SC_SPORADIC_SERVER,
>
>    _SC_THREAD_SPORADIC_SERVER,
>
>    _SC_SYSTEM_DATABASE,
>
>    _SC_SYSTEM_DATABASE_R,
>
>    _SC_TIMEOUTS,
>
>    _SC_TYPED_MEMORY_OBJECTS,
>
>    _SC_USER_GROUPS,
>
>    _SC_USER_GROUPS_R,
>
>    _SC_2_PBS,
>
>    _SC_2_PBS_ACCOUNTING,
>
>    _SC_2_PBS_LOCATE,
>
>    _SC_2_PBS_MESSAGE,
>
>    _SC_2_PBS_TRACK,
>
>    _SC_SYMLOOP_MAX,
>
>    _SC_STREAMS,
>
>    _SC_2_PBS_CHECKPOINT,
>
>
>    _SC_V6_ILP32_OFF32,
>
>    _SC_V6_ILP32_OFFBIG,
>
>    _SC_V6_LP64_OFF64,
>
>    _SC_V6_LPBIG_OFFBIG,
>
>
>    _SC_HOST_NAME_MAX,
>
>    _SC_TRACE,
>
>    _SC_TRACE_EVENT_FILTER,
>
>    _SC_TRACE_INHERIT,
>
>    _SC_TRACE_LOG,
>
>
>    _SC_LEVEL1_ICACHE_SIZE,
>
>    _SC_LEVEL1_ICACHE_ASSOC,
>
>    _SC_LEVEL1_ICACHE_LINESIZE,
>
>    _SC_LEVEL1_DCACHE_SIZE,
>
>    _SC_LEVEL1_DCACHE_ASSOC,
>
>    _SC_LEVEL1_DCACHE_LINESIZE,
>
>    _SC_LEVEL2_CACHE_SIZE,
>
>    _SC_LEVEL2_CACHE_ASSOC,
>
>    _SC_LEVEL2_CACHE_LINESIZE,
>
>    _SC_LEVEL3_CACHE_SIZE,
>
>    _SC_LEVEL3_CACHE_ASSOC,
>
>    _SC_LEVEL3_CACHE_LINESIZE,
>
>    _SC_LEVEL4_CACHE_SIZE,
>
>    _SC_LEVEL4_CACHE_ASSOC,
>
>    _SC_LEVEL4_CACHE_LINESIZE,
>
>
>
>    _SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
>
>    _SC_RAW_SOCKETS,
>
>
>    _SC_V7_ILP32_OFF32,
>
>    _SC_V7_ILP32_OFFBIG,
>
>    _SC_V7_LP64_OFF64,
>
>    _SC_V7_LPBIG_OFFBIG,
>
>
>    _SC_SS_REPL_MAX,
>
>
>    _SC_TRACE_EVENT_NAME_MAX,
>
>    _SC_TRACE_NAME_MAX,
>
>    _SC_TRACE_SYS_MAX,
>
>    _SC_TRACE_USER_EVENT_MAX,
>
>
>    _SC_XOPEN_STREAMS,
>
>
>    _SC_THREAD_ROBUST_PRIO_INHERIT,
>
>    _SC_THREAD_ROBUST_PRIO_PROTECT
>
>  };
>
>
>enum
>  {
>    _CS_PATH,
>
>
>    _CS_V6_WIDTH_RESTRICTED_ENVS,
>
>
>
>    _CS_GNU_LIBC_VERSION,
>
>    _CS_GNU_LIBPTHREAD_VERSION,
>
>
>    _CS_V5_WIDTH_RESTRICTED_ENVS,
>
>
>
>    _CS_V7_WIDTH_RESTRICTED_ENVS,
>
>
>
>    _CS_LFS_CFLAGS = 1000,
>
>    _CS_LFS_LDFLAGS,
>
>    _CS_LFS_LIBS,
>
>    _CS_LFS_LINTFLAGS,
>
>    _CS_LFS64_CFLAGS,
>
>    _CS_LFS64_LDFLAGS,
>
>    _CS_LFS64_LIBS,
>
>    _CS_LFS64_LINTFLAGS,
>
>
>    _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
>
>    _CS_XBS5_ILP32_OFF32_LDFLAGS,
>
>    _CS_XBS5_ILP32_OFF32_LIBS,
>
>    _CS_XBS5_ILP32_OFF32_LINTFLAGS,
>
>    _CS_XBS5_ILP32_OFFBIG_CFLAGS,
>
>    _CS_XBS5_ILP32_OFFBIG_LDFLAGS,
>
>    _CS_XBS5_ILP32_OFFBIG_LIBS,
>
>    _CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
>
>    _CS_XBS5_LP64_OFF64_CFLAGS,
>
>    _CS_XBS5_LP64_OFF64_LDFLAGS,
>
>    _CS_XBS5_LP64_OFF64_LIBS,
>
>    _CS_XBS5_LP64_OFF64_LINTFLAGS,
>
>    _CS_XBS5_LPBIG_OFFBIG_CFLAGS,
>
>    _CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
>
>    _CS_XBS5_LPBIG_OFFBIG_LIBS,
>
>    _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
>
>
>    _CS_POSIX_V6_ILP32_OFF32_CFLAGS,
>
>    _CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
>
>    _CS_POSIX_V6_ILP32_OFF32_LIBS,
>
>    _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
>
>    _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
>
>    _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
>
>    _CS_POSIX_V6_ILP32_OFFBIG_LIBS,
>
>    _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
>
>    _CS_POSIX_V6_LP64_OFF64_CFLAGS,
>
>    _CS_POSIX_V6_LP64_OFF64_LDFLAGS,
>
>    _CS_POSIX_V6_LP64_OFF64_LIBS,
>
>    _CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
>
>    _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
>
>    _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
>
>    _CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
>
>    _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,
>
>
>    _CS_POSIX_V7_ILP32_OFF32_CFLAGS,
>
>    _CS_POSIX_V7_ILP32_OFF32_LDFLAGS,
>
>    _CS_POSIX_V7_ILP32_OFF32_LIBS,
>
>    _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,
>
>    _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,
>
>    _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,
>
>    _CS_POSIX_V7_ILP32_OFFBIG_LIBS,
>
>    _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,
>
>    _CS_POSIX_V7_LP64_OFF64_CFLAGS,
>
>    _CS_POSIX_V7_LP64_OFF64_LDFLAGS,
>
>    _CS_POSIX_V7_LP64_OFF64_LIBS,
>
>    _CS_POSIX_V7_LP64_OFF64_LINTFLAGS,
>
>    _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,
>
>    _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,
>
>    _CS_POSIX_V7_LPBIG_OFFBIG_LIBS,
>
>    _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS,
>
>
>    _CS_V6_ENV,
>
>    _CS_V7_ENV
>
>  };
># 610 "/usr/include/unistd.h" 2 3 4
>
>
>extern long int pathconf (const char *__path, int __name)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern long int fpathconf (int __fd, int __name) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern long int sysconf (int __name) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern size_t confstr (int __name, char *__buf, size_t __len) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern __pid_t getpid (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __pid_t getppid (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __pid_t getpgrp (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __pid_t __getpgid (__pid_t __pid) __attribute__ ((__nothrow__ , __leaf__));
>
>extern __pid_t getpgid (__pid_t __pid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int setpgid (__pid_t __pid, __pid_t __pgid) __attribute__ ((__nothrow__ , __leaf__));
># 660 "/usr/include/unistd.h" 3 4
>extern int setpgrp (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern __pid_t setsid (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern __pid_t getsid (__pid_t __pid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern __uid_t getuid (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __uid_t geteuid (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __gid_t getgid (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern __gid_t getegid (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int getgroups (int __size, __gid_t __list[]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>extern int group_member (__gid_t __gid) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern int setuid (__uid_t __uid) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int setreuid (__uid_t __ruid, __uid_t __euid) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int seteuid (__uid_t __uid) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern int setgid (__gid_t __gid) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int setregid (__gid_t __rgid, __gid_t __egid) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int setegid (__gid_t __gid) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern __pid_t fork (void) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>extern __pid_t vfork (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern char *ttyname (int __fd) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
>
>
>
>extern int isatty (int __fd) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int ttyslot (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int link (const char *__from, const char *__to)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int linkat (int __fromfd, const char *__from, int __tofd,
>     const char *__to, int __flags)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 4))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int symlink (const char *__from, const char *__to)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern ssize_t readlink (const char *__restrict __path,
>    char *__restrict __buf, size_t __len)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>extern int symlinkat (const char *__from, int __tofd,
>        const char *__to) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 3))) __attribute__ ((__warn_unused_result__));
>
>
>extern ssize_t readlinkat (int __fd, const char *__restrict __path,
>      char *__restrict __buf, size_t __len)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
>
>
>
>extern int unlink (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int unlinkat (int __fd, const char *__name, int __flag)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>extern int rmdir (const char *__path) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern __pid_t tcgetpgrp (int __fd) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern char *getlogin (void);
>
>
>
>
>
>
>
>extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int setlogin (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 871 "/usr/include/unistd.h" 3 4
># 1 "./getopt.h" 1 3 4
># 67 "./getopt.h" 3 4
>extern int opterr;
>extern int optind;
>extern int optopt;
>extern int optreset;
>extern char *optarg;
>
>extern int getopt (int, char * const *, const char *);
># 89 "./getopt.h" 3 4
>struct option {
>    const char *name;
>    int has_arg;
>    int *flag;
>    int val;
>};
>
>extern int getopt_long (int, char *const *, const char *, const struct option *, int *);
># 872 "/usr/include/unistd.h" 2 3 4
>
>
>
>
>
>
>
>extern int gethostname (char *__name, size_t __len) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int sethostname (const char *__name, size_t __len)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>extern int sethostid (long int __id) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int getdomainname (char *__name, size_t __len)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>extern int setdomainname (const char *__name, size_t __len)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int vhangup (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int revoke (const char *__file) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>extern int profil (unsigned short int *__sample_buffer, size_t __size,
>     size_t __offset, unsigned int __scale)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int acct (const char *__name) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern char *getusershell (void) __attribute__ ((__nothrow__ , __leaf__));
>extern void endusershell (void) __attribute__ ((__nothrow__ , __leaf__));
>extern void setusershell (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int daemon (int __nochdir, int __noclose) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>extern int chroot (const char *__path) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int fsync (int __fd);
>
>
>
>
>
>extern int syncfs (int __fd) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>extern long int gethostid (void);
>
>
>extern void sync (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>extern int getpagesize (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>extern int getdtablesize (void) __attribute__ ((__nothrow__ , __leaf__));
># 997 "/usr/include/unistd.h" 3 4
>extern int truncate (const char *__file, __off64_t __length) __asm__ ("" "truncate64") __attribute__ ((__nothrow__ , __leaf__))
>
>                  __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int truncate64 (const char *__file, __off64_t __length)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
># 1019 "/usr/include/unistd.h" 3 4
>extern int ftruncate (int __fd, __off64_t __length) __asm__ ("" "ftruncate64") __attribute__ ((__nothrow__ , __leaf__))
>                   __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern int ftruncate64 (int __fd, __off64_t __length) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
># 1037 "/usr/include/unistd.h" 3 4
>extern int brk (void *__addr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>extern void *sbrk (intptr_t __delta) __attribute__ ((__nothrow__ , __leaf__));
># 1058 "/usr/include/unistd.h" 3 4
>extern long int syscall (long int __sysno, ...) __attribute__ ((__nothrow__ , __leaf__));
># 1112 "/usr/include/unistd.h" 3 4
>extern int fdatasync (int __fildes);
>
>
>
>
>
>
>
>extern char *crypt (const char *__key, const char *__salt)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern void encrypt (char *__glibc_block, int __edflag)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern void swab (const void *__restrict __from, void *__restrict __to,
>    ssize_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
># 1148 "/usr/include/unistd.h" 3 4
># 1 "/usr/include/bits/unistd.h" 1 3 4
># 23 "/usr/include/bits/unistd.h" 3 4
>extern ssize_t __read_chk (int __fd, void *__buf, size_t __nbytes,
>      size_t __buflen) __attribute__ ((__warn_unused_result__));
>extern ssize_t __read_alias (int __fd, void *__buf, size_t __nbytes) __asm__ ("" "read")
>                               __attribute__ ((__warn_unused_result__));
>extern ssize_t __read_chk_warn (int __fd, void *__buf, size_t __nbytes, size_t __buflen) __asm__ ("" "__read_chk")
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("read called with bigger length than size of " "the destination buffer")))
>                                  ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
>read (int __fd, void *__buf, size_t __nbytes)
>{
>  if (__builtin_object_size (__buf, 0) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__nbytes))
> return __read_chk (__fd, __buf, __nbytes, __builtin_object_size (__buf, 0));
>
>      if (__nbytes > __builtin_object_size (__buf, 0))
> return __read_chk_warn (__fd, __buf, __nbytes, __builtin_object_size (__buf, 0));
>    }
>  return __read_alias (__fd, __buf, __nbytes);
>}
>
>
>extern ssize_t __pread_chk (int __fd, void *__buf, size_t __nbytes,
>       __off_t __offset, size_t __bufsize) __attribute__ ((__warn_unused_result__));
>extern ssize_t __pread64_chk (int __fd, void *__buf, size_t __nbytes,
>         __off64_t __offset, size_t __bufsize) __attribute__ ((__warn_unused_result__));
>extern ssize_t __pread_alias (int __fd, void *__buf, size_t __nbytes, __off_t __offset) __asm__ ("" "pread")
>
>                                 __attribute__ ((__warn_unused_result__));
>extern ssize_t __pread64_alias (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pread64")
>
>                                     __attribute__ ((__warn_unused_result__));
>extern ssize_t __pread_chk_warn (int __fd, void *__buf, size_t __nbytes, __off_t __offset, size_t __bufsize) __asm__ ("" "__pread_chk")
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("pread called with bigger length than size of " "the destination buffer")))
>                                  ;
>extern ssize_t __pread64_chk_warn (int __fd, void *__buf, size_t __nbytes, __off64_t __offset, size_t __bufsize) __asm__ ("" "__pread64_chk")
>
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("pread64 called with bigger length than size of " "the destination buffer")))
>                                  ;
># 86 "/usr/include/bits/unistd.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
>pread (int __fd, void *__buf, size_t __nbytes, __off64_t __offset)
>{
>  if (__builtin_object_size (__buf, 0) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__nbytes))
> return __pread64_chk (__fd, __buf, __nbytes, __offset, __builtin_object_size (__buf, 0));
>
>      if ( __nbytes > __builtin_object_size (__buf, 0))
> return __pread64_chk_warn (__fd, __buf, __nbytes, __offset,
>       __builtin_object_size (__buf, 0));
>    }
>
>  return __pread64_alias (__fd, __buf, __nbytes, __offset);
>}
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
>pread64 (int __fd, void *__buf, size_t __nbytes, __off64_t __offset)
>{
>  if (__builtin_object_size (__buf, 0) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__nbytes))
> return __pread64_chk (__fd, __buf, __nbytes, __offset, __builtin_object_size (__buf, 0));
>
>      if ( __nbytes > __builtin_object_size (__buf, 0))
> return __pread64_chk_warn (__fd, __buf, __nbytes, __offset,
>       __builtin_object_size (__buf, 0));
>    }
>
>  return __pread64_alias (__fd, __buf, __nbytes, __offset);
>}
>
>
>
>
>extern ssize_t __readlink_chk (const char *__restrict __path,
>          char *__restrict __buf, size_t __len,
>          size_t __buflen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
>extern ssize_t __readlink_alias (const char *__restrict __path, char *__restrict __buf, size_t __len) __asm__ ("" "readlink") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
>extern ssize_t __readlink_chk_warn (const char *__restrict __path, char *__restrict __buf, size_t __len, size_t __buflen) __asm__ ("" "__readlink_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>
>     __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("readlink called with bigger length " "than size of destination buffer")))
>                                         ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__)) ssize_t
>__attribute__ ((__nothrow__ , __leaf__)) readlink (const char *__restrict __path, char *__restrict __buf, size_t __len)
>
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__len))
> return __readlink_chk (__path, __buf, __len, __builtin_object_size (__buf, 2 > 1));
>
>      if ( __len > __builtin_object_size (__buf, 2 > 1))
> return __readlink_chk_warn (__path, __buf, __len, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __readlink_alias (__path, __buf, __len);
>}
>
>
>
>extern ssize_t __readlinkat_chk (int __fd, const char *__restrict __path,
>     char *__restrict __buf, size_t __len,
>     size_t __buflen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
>extern ssize_t __readlinkat_alias (int __fd, const char *__restrict __path, char *__restrict __buf, size_t __len) __asm__ ("" "readlinkat") __attribute__ ((__nothrow__ , __leaf__))
>
>
>
>     __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
>extern ssize_t __readlinkat_chk_warn (int __fd, const char *__restrict __path, char *__restrict __buf, size_t __len, size_t __buflen) __asm__ ("" "__readlinkat_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>
>     __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("readlinkat called with bigger " "length than size of destination " "buffer")))
>
>                ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__)) ssize_t
>__attribute__ ((__nothrow__ , __leaf__)) readlinkat (int __fd, const char *__restrict __path, char *__restrict __buf, size_t __len)
>
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__len))
> return __readlinkat_chk (__fd, __path, __buf, __len, __builtin_object_size (__buf, 2 > 1));
>
>      if (__len > __builtin_object_size (__buf, 2 > 1))
> return __readlinkat_chk_warn (__fd, __path, __buf, __len,
>          __builtin_object_size (__buf, 2 > 1));
>    }
>  return __readlinkat_alias (__fd, __path, __buf, __len);
>}
>
>
>extern char *__getcwd_chk (char *__buf, size_t __size, size_t __buflen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>extern char *__getcwd_alias (char *__buf, size_t __size) __asm__ ("" "getcwd") __attribute__ ((__nothrow__ , __leaf__))
>                                              __attribute__ ((__warn_unused_result__));
>extern char *__getcwd_chk_warn (char *__buf, size_t __size, size_t __buflen) __asm__ ("" "__getcwd_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getcwd caller with bigger length than size of " "destination buffer")))
>                              ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) getcwd (char *__buf, size_t __size)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__size))
> return __getcwd_chk (__buf, __size, __builtin_object_size (__buf, 2 > 1));
>
>      if (__size > __builtin_object_size (__buf, 2 > 1))
> return __getcwd_chk_warn (__buf, __size, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __getcwd_alias (__buf, __size);
>}
>
>
>extern char *__getwd_chk (char *__buf, size_t buflen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>extern char *__getwd_warn (char *__buf) __asm__ ("" "getwd") __attribute__ ((__nothrow__ , __leaf__))
>     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("please use getcwd instead, as getwd " "doesn't specify buffer size")))
>                                         ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) __attribute__ ((__warn_unused_result__)) char *
>__attribute__ ((__nothrow__ , __leaf__)) getwd (char *__buf)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    return __getwd_chk (__buf, __builtin_object_size (__buf, 2 > 1));
>  return __getwd_warn (__buf);
>}
>
>
>extern size_t __confstr_chk (int __name, char *__buf, size_t __len,
>        size_t __buflen) __attribute__ ((__nothrow__ , __leaf__));
>extern size_t __confstr_alias (int __name, char *__buf, size_t __len) __asm__ ("" "confstr") __attribute__ ((__nothrow__ , __leaf__))
>                             ;
>extern size_t __confstr_chk_warn (int __name, char *__buf, size_t __len, size_t __buflen) __asm__ ("" "__confstr_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__((__warning__ ("confstr called with bigger length than size of destination " "buffer")))
>            ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) size_t
>__attribute__ ((__nothrow__ , __leaf__)) confstr (int __name, char *__buf, size_t __len)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__len))
> return __confstr_chk (__name, __buf, __len, __builtin_object_size (__buf, 2 > 1));
>
>      if (__builtin_object_size (__buf, 2 > 1) < __len)
> return __confstr_chk_warn (__name, __buf, __len, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __confstr_alias (__name, __buf, __len);
>}
>
>
>extern int __getgroups_chk (int __size, __gid_t __list[], size_t __listlen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__));
>extern int __getgroups_alias (int __size, __gid_t __list[]) __asm__ ("" "getgroups") __attribute__ ((__nothrow__ , __leaf__))
>                 __attribute__ ((__warn_unused_result__));
>extern int __getgroups_chk_warn (int __size, __gid_t __list[], size_t __listlen) __asm__ ("" "__getgroups_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getgroups called with bigger group count than what " "can fit into destination buffer")))
>                                           ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) getgroups (int __size, __gid_t __list[])
>{
>  if (__builtin_object_size (__list, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__size) || __size < 0)
> return __getgroups_chk (__size, __list, __builtin_object_size (__list, 2 > 1));
>
>      if (__size * sizeof (__gid_t) > __builtin_object_size (__list, 2 > 1))
> return __getgroups_chk_warn (__size, __list, __builtin_object_size (__list, 2 > 1));
>    }
>  return __getgroups_alias (__size, __list);
>}
>
>
>extern int __ttyname_r_chk (int __fd, char *__buf, size_t __buflen,
>       size_t __nreal) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>extern int __ttyname_r_alias (int __fd, char *__buf, size_t __buflen) __asm__ ("" "ttyname_r") __attribute__ ((__nothrow__ , __leaf__))
>
>     __attribute__ ((__nonnull__ (2)));
>extern int __ttyname_r_chk_warn (int __fd, char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__ttyname_r_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__ ((__nonnull__ (2))) __attribute__((__warning__ ("ttyname_r called with bigger buflen than " "size of destination buffer")))
>                                  ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) ttyname_r (int __fd, char *__buf, size_t __buflen)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__buflen))
> return __ttyname_r_chk (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>
>      if (__buflen > __builtin_object_size (__buf, 2 > 1))
> return __ttyname_r_chk_warn (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __ttyname_r_alias (__fd, __buf, __buflen);
>}
>
>
>
>extern int __getlogin_r_chk (char *__buf, size_t __buflen, size_t __nreal)
>     __attribute__ ((__nonnull__ (1)));
>extern int __getlogin_r_alias (char *__buf, size_t __buflen) __asm__ ("" "getlogin_r")
>                     __attribute__ ((__nonnull__ (1)));
>extern int __getlogin_r_chk_warn (char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__getlogin_r_chk")
>
>
>     __attribute__ ((__nonnull__ (1))) __attribute__((__warning__ ("getlogin_r called with bigger buflen than " "size of destination buffer")))
>                                  ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>getlogin_r (char *__buf, size_t __buflen)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__buflen))
> return __getlogin_r_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>
>      if (__buflen > __builtin_object_size (__buf, 2 > 1))
> return __getlogin_r_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __getlogin_r_alias (__buf, __buflen);
>}
>
>
>
>
>extern int __gethostname_chk (char *__buf, size_t __buflen, size_t __nreal)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>extern int __gethostname_alias (char *__buf, size_t __buflen) __asm__ ("" "gethostname") __attribute__ ((__nothrow__ , __leaf__))
>                   __attribute__ ((__nonnull__ (1)));
>extern int __gethostname_chk_warn (char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__gethostname_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__ ((__nonnull__ (1))) __attribute__((__warning__ ("gethostname called with bigger buflen than " "size of destination buffer")))
>                                  ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) gethostname (char *__buf, size_t __buflen)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__buflen))
> return __gethostname_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>
>      if (__buflen > __builtin_object_size (__buf, 2 > 1))
> return __gethostname_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __gethostname_alias (__buf, __buflen);
>}
>
>
>
>
>extern int __getdomainname_chk (char *__buf, size_t __buflen, size_t __nreal)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>extern int __getdomainname_alias (char *__buf, size_t __buflen) __asm__ ("" "getdomainname") __attribute__ ((__nothrow__ , __leaf__))
>
>                     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
>extern int __getdomainname_chk_warn (char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__getdomainname_chk") __attribute__ ((__nothrow__ , __leaf__))
>
>
>     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getdomainname called with bigger " "buflen than size of destination " "buffer")))
>
>                    ;
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__artificial__)) int
>__attribute__ ((__nothrow__ , __leaf__)) getdomainname (char *__buf, size_t __buflen)
>{
>  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
>    {
>      if (!__builtin_constant_p (__buflen))
> return __getdomainname_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>
>      if (__buflen > __builtin_object_size (__buf, 2 > 1))
> return __getdomainname_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
>    }
>  return __getdomainname_alias (__buf, __buflen);
>}
># 1149 "/usr/include/unistd.h" 2 3 4
>
>
>
># 453 "/usr/include/zconf.h" 2 3 4
># 35 "/usr/include/zlib.h" 2 3 4
># 80 "/usr/include/zlib.h" 3 4
>typedef voidpf (*alloc_func) (voidpf opaque, uInt items, uInt size);
>typedef void (*free_func) (voidpf opaque, voidpf address);
>
>struct internal_state;
>
>typedef struct z_stream_s {
>    Bytef *next_in;
>    uInt avail_in;
>    uLong total_in;
>
>    Bytef *next_out;
>    uInt avail_out;
>    uLong total_out;
>
>    char *msg;
>    struct internal_state *state;
>
>    alloc_func zalloc;
>    free_func zfree;
>    voidpf opaque;
>
>    int data_type;
>    uLong adler;
>    uLong reserved;
>} z_stream;
>
>typedef z_stream *z_streamp;
>
>
>
>
>
>typedef struct gz_header_s {
>    int text;
>    uLong time;
>    int xflags;
>    int os;
>    Bytef *extra;
>    uInt extra_len;
>    uInt extra_max;
>    Bytef *name;
>    uInt name_max;
>    Bytef *comment;
>    uInt comm_max;
>    int hcrc;
>    int done;
>
>} gz_header;
>
>typedef gz_header *gz_headerp;
># 216 "/usr/include/zlib.h" 3 4
>extern const char * zlibVersion (void);
># 246 "/usr/include/zlib.h" 3 4
>extern int deflate (z_streamp strm, int flush);
># 353 "/usr/include/zlib.h" 3 4
>extern int deflateEnd (z_streamp strm);
># 392 "/usr/include/zlib.h" 3 4
>extern int inflate (z_streamp strm, int flush);
># 508 "/usr/include/zlib.h" 3 4
>extern int inflateEnd (z_streamp strm);
># 587 "/usr/include/zlib.h" 3 4
>extern int deflateSetDictionary (z_streamp strm, const Bytef *dictionary, uInt dictLength)
>
>                                                               ;
># 631 "/usr/include/zlib.h" 3 4
>extern int deflateCopy (z_streamp dest, z_streamp source)
>                                                      ;
># 649 "/usr/include/zlib.h" 3 4
>extern int deflateReset (z_streamp strm);
># 660 "/usr/include/zlib.h" 3 4
>extern int deflateParams (z_streamp strm, int level, int strategy)
>
>                                                    ;
># 681 "/usr/include/zlib.h" 3 4
>extern int deflateTune (z_streamp strm, int good_length, int max_lazy, int nice_length, int max_chain)
>
>
>
>                                                   ;
># 698 "/usr/include/zlib.h" 3 4
>extern uLong deflateBound (z_streamp strm, uLong sourceLen)
>                                                        ;
># 713 "/usr/include/zlib.h" 3 4
>extern int deflatePending (z_streamp strm, unsigned *pending, int *bits)
>
>                                                  ;
># 728 "/usr/include/zlib.h" 3 4
>extern int deflatePrime (z_streamp strm, int bits, int value)
>
>                                                ;
># 745 "/usr/include/zlib.h" 3 4
>extern int deflateSetHeader (z_streamp strm, gz_headerp head)
>                                                          ;
># 819 "/usr/include/zlib.h" 3 4
>extern int inflateSetDictionary (z_streamp strm, const Bytef *dictionary, uInt dictLength)
>
>                                                               ;
># 842 "/usr/include/zlib.h" 3 4
>extern int inflateGetDictionary (z_streamp strm, Bytef *dictionary, uInt *dictLength)
>
>                                                                ;
># 857 "/usr/include/zlib.h" 3 4
>extern int inflateSync (z_streamp strm);
># 876 "/usr/include/zlib.h" 3 4
>extern int inflateCopy (z_streamp dest, z_streamp source)
>                                                      ;
># 892 "/usr/include/zlib.h" 3 4
>extern int inflateReset (z_streamp strm);
># 902 "/usr/include/zlib.h" 3 4
>extern int inflateReset2 (z_streamp strm, int windowBits)
>                                                      ;
># 914 "/usr/include/zlib.h" 3 4
>extern int inflatePrime (z_streamp strm, int bits, int value)
>
>                                                ;
># 935 "/usr/include/zlib.h" 3 4
>extern long inflateMark (z_streamp strm);
># 963 "/usr/include/zlib.h" 3 4
>extern int inflateGetHeader (z_streamp strm, gz_headerp head)
>                                                          ;
># 1025 "/usr/include/zlib.h" 3 4
>typedef unsigned (*in_func) (void *, unsigned char * *)
>                                                                   ;
>typedef int (*out_func) (void *, unsigned char *, unsigned);
>
>extern int inflateBack (z_streamp strm, in_func in, void *in_desc, out_func out, void *out_desc)
>
>                                                                      ;
># 1099 "/usr/include/zlib.h" 3 4
>extern int inflateBackEnd (z_streamp strm);
>
>
>
>
>
>
>
>extern uLong zlibCompileFlags (void);
># 1160 "/usr/include/zlib.h" 3 4
>extern int compress (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen)
>                                                                       ;
># 1174 "/usr/include/zlib.h" 3 4
>extern int compress2 (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen, int level)
>
>                                             ;
># 1190 "/usr/include/zlib.h" 3 4
>extern uLong compressBound (uLong sourceLen);
>
>
>
>
>
>
>extern int uncompress (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen)
>                                                                         ;
># 1224 "/usr/include/zlib.h" 3 4
>typedef struct gzFile_s *gzFile;
># 1264 "/usr/include/zlib.h" 3 4
>extern gzFile gzdopen (int fd, const char *mode);
># 1287 "/usr/include/zlib.h" 3 4
>extern int gzbuffer (gzFile file, unsigned size);
># 1304 "/usr/include/zlib.h" 3 4
>extern int gzsetparams (gzFile file, int level, int strategy);
># 1313 "/usr/include/zlib.h" 3 4
>extern int gzread (gzFile file, voidp buf, unsigned len);
># 1341 "/usr/include/zlib.h" 3 4
>extern int gzwrite (gzFile file, voidpc buf, unsigned len)
>                                                          ;
>
>
>
>
>
>
>extern int gzprintf (gzFile file, const char *format, ...);
># 1364 "/usr/include/zlib.h" 3 4
>extern int gzputs (gzFile file, const char *s);
>
>
>
>
>
>
>
>extern char * gzgets (gzFile file, char *buf, int len);
># 1385 "/usr/include/zlib.h" 3 4
>extern int gzputc (gzFile file, int c);
>
>
>
>
>
>extern int gzgetc (gzFile file);
># 1400 "/usr/include/zlib.h" 3 4
>extern int gzungetc (int c, gzFile file);
># 1412 "/usr/include/zlib.h" 3 4
>extern int gzflush (gzFile file, int flush);
># 1447 "/usr/include/zlib.h" 3 4
>extern int gzrewind (gzFile file);
># 1475 "/usr/include/zlib.h" 3 4
>extern int gzeof (gzFile file);
># 1490 "/usr/include/zlib.h" 3 4
>extern int gzdirect (gzFile file);
># 1511 "/usr/include/zlib.h" 3 4
>extern int gzclose (gzFile file);
># 1524 "/usr/include/zlib.h" 3 4
>extern int gzclose_r (gzFile file);
>extern int gzclose_w (gzFile file);
># 1536 "/usr/include/zlib.h" 3 4
>extern const char * gzerror (gzFile file, int *errnum);
># 1552 "/usr/include/zlib.h" 3 4
>extern void gzclearerr (gzFile file);
># 1569 "/usr/include/zlib.h" 3 4
>extern uLong adler32 (uLong adler, const Bytef *buf, uInt len);
># 1600 "/usr/include/zlib.h" 3 4
>extern uLong crc32 (uLong crc, const Bytef *buf, uInt len);
># 1633 "/usr/include/zlib.h" 3 4
>extern int deflateInit_ (z_streamp strm, int level, const char *version, int stream_size)
>                                                                           ;
>extern int inflateInit_ (z_streamp strm, const char *version, int stream_size)
>                                                                           ;
>extern int deflateInit2_ (z_streamp strm, int level, int method, int windowBits, int memLevel, int strategy, const char *version, int stream_size)
>
>
>                                                       ;
>extern int inflateInit2_ (z_streamp strm, int windowBits, const char *version, int stream_size)
>                                                                            ;
>extern int inflateBackInit_ (z_streamp strm, int windowBits, unsigned char *window, const char *version, int stream_size)
>
>
>                                                          ;
># 1670 "/usr/include/zlib.h" 3 4
>struct gzFile_s {
>    unsigned have;
>    unsigned char *next;
>    off64_t pos;
>};
>extern int gzgetc_ (gzFile file);
># 1692 "/usr/include/zlib.h" 3 4
>   extern gzFile gzopen64 (const char *, const char *);
>   extern off64_t gzseek64 (gzFile, off64_t, int);
>   extern off64_t gztell64 (gzFile);
>   extern off64_t gzoffset64 (gzFile);
>   extern uLong adler32_combine64 (uLong, uLong, off64_t);
>   extern uLong crc32_combine64 (uLong, uLong, off64_t);
># 1742 "/usr/include/zlib.h" 3 4
>    struct internal_state {int dummy;};
>
>
>
>extern const char * zError (int);
>extern int inflateSyncPoint (z_streamp);
>extern const z_crc_t * get_crc_table (void);
>extern int inflateUndermine (z_streamp, int);
>extern int inflateResetKeep (z_streamp);
>extern int deflateResetKeep (z_streamp);
>
>
>
>
>
>
>extern int gzvprintf (gzFile file, const char *format, va_list va)
>
>                                                              ;
># 205 "hstdinc.h" 2
>
>
># 1 "/usr/include/sys/capability.h" 1 3 4
># 29 "/usr/include/sys/capability.h" 3 4
># 1 "/usr/include/linux/capability.h" 1 3 4
># 18 "/usr/include/linux/capability.h" 3 4
>struct task_struct;
># 40 "/usr/include/linux/capability.h" 3 4
>typedef struct __user_cap_header_struct {
> __u32 version;
> int pid;
>} *cap_user_header_t;
>
>typedef struct __user_cap_data_struct {
>        __u32 effective;
>        __u32 permitted;
>        __u32 inheritable;
>} *cap_user_data_t;
># 69 "/usr/include/linux/capability.h" 3 4
>struct vfs_cap_data {
> __le32 magic_etc;
> struct {
>  __le32 permitted;
>  __le32 inheritable;
> } data[2];
>};
># 30 "/usr/include/sys/capability.h" 2 3 4
># 1 "/usr/include/linux/xattr.h" 1 3 4
># 11 "/usr/include/linux/xattr.h" 3 4
># 1 "/usr/include/linux/libc-compat.h" 1 3 4
># 12 "/usr/include/linux/xattr.h" 2 3 4
># 31 "/usr/include/sys/capability.h" 2 3 4
># 40 "/usr/include/sys/capability.h" 3 4
>typedef struct _cap_struct *cap_t;
>
>
>
>
>
>
>
>typedef int cap_value_t;
>
>
>
>
>typedef enum {
>    CAP_EFFECTIVE=0,
>    CAP_PERMITTED=1,
>    CAP_INHERITABLE=2
>} cap_flag_t;
>
>
>
>
>typedef enum {
>    CAP_CLEAR=0,
>    CAP_SET=1
>} cap_flag_value_t;
>
>
>
>
>
>
>extern cap_t cap_dup(cap_t);
>extern int cap_free(void *);
>extern cap_t cap_init(void);
>
>
>extern int cap_get_flag(cap_t, cap_value_t, cap_flag_t, cap_flag_value_t *);
>extern int cap_set_flag(cap_t, cap_flag_t, int, const cap_value_t *,
>       cap_flag_value_t);
>extern int cap_clear(cap_t);
>extern int cap_clear_flag(cap_t, cap_flag_t);
>
>
>extern cap_t cap_get_fd(int);
>extern cap_t cap_get_file(const char *);
>extern int cap_set_fd(int, cap_t);
>extern int cap_set_file(const char *, cap_t);
>
>
>extern cap_t cap_get_proc(void);
>extern cap_t cap_get_pid(pid_t);
>extern int cap_set_proc(cap_t);
>
>extern int cap_get_bound(cap_value_t);
>extern int cap_drop_bound(cap_value_t);
>
>
>
>
>extern ssize_t cap_size(cap_t);
>extern ssize_t cap_copy_ext(void *, cap_t, ssize_t);
>extern cap_t cap_copy_int(const void *);
>
>
>extern cap_t cap_from_text(const char *);
>extern char * cap_to_text(cap_t, ssize_t *);
>extern int cap_from_name(const char *, cap_value_t *);
>extern char * cap_to_name(cap_value_t);
>
>
>extern int cap_compare(cap_t, cap_t);
>
>
>extern int capset(cap_user_header_t header, cap_user_data_t data);
>extern int capget(cap_user_header_t header, const cap_user_data_t data);
>
>
>extern int capgetp(pid_t pid, cap_t cap_d);
>
>
>extern int capsetp(pid_t pid, cap_t cap_d);
># 208 "hstdinc.h" 2
>
>
># 1 "/usr/include/sys/prctl.h" 1 3 4
># 22 "/usr/include/sys/prctl.h" 3 4
># 1 "/usr/include/linux/prctl.h" 1 3 4
># 23 "/usr/include/sys/prctl.h" 2 3 4
>
>
>
>
>extern int prctl (int __option, ...) __attribute__ ((__nothrow__ , __leaf__));
>
>
># 211 "hstdinc.h" 2
># 226 "hstdinc.h"
># 1 "hostopts.h" 1
># 227 "hstdinc.h" 2
># 1 "htypes.h" 1
># 33 "htypes.h"
>typedef int8_t S8;
>typedef int16_t S16;
>typedef int32_t S32;
>typedef int64_t S64;
>
>typedef uint8_t U8;
>typedef uint16_t U16;
>typedef uint32_t U32;
>typedef uint64_t U64;
>
>
>typedef uint8_t BYTE;
>
>typedef uint8_t HWORD[2];
>typedef uint8_t FWORD[4];
>typedef uint8_t DBLWRD[8];
>typedef uint8_t QWORD[16];
># 148 "htypes.h"
>  typedef void GETSET_SOCKOPT_T;
>  typedef char *const *EXECV_ARG2_ARGV_T;
># 165 "htypes.h"
>typedef struct SYSBLK SYSBLK;
>typedef struct REGS REGS;
>typedef struct VFREGS VFREGS;
>typedef struct ZPBLK ZPBLK;
>typedef struct DEVBLK DEVBLK;
>typedef struct IOINT IOINT;
>
>typedef struct DEVDATA DEVDATA;
>typedef struct DEVGRP DEVGRP;
>typedef struct DEVHND DEVHND;
>typedef struct SHRD SHRD;
>
>
>typedef struct GUISTAT GUISTAT;
>
>
>
>
>
>
>typedef struct CKDDASD_DEVHDR CKDDASD_DEVHDR;
>typedef struct CKDDASD_TRKHDR CKDDASD_TRKHDR;
>typedef struct CKDDASD_RECHDR CKDDASD_RECHDR;
>typedef struct CCKDDASD_DEVHDR CCKDDASD_DEVHDR;
>typedef struct CCKD_L2ENT CCKD_L2ENT;
>
>typedef struct CCKD_FREEBLK CCKD_FREEBLK;
>typedef struct CCKD_IFREEBLK CCKD_IFREEBLK;
>typedef struct CCKD_RA CCKD_RA;
>
>typedef struct CCKDBLK CCKDBLK;
>typedef struct CCKDDASD_EXT CCKDDASD_EXT;
>
>typedef struct COMMADPT COMMADPT;
>typedef struct bind_struct bind_struct;
>
>typedef struct TAPEMEDIA_HANDLER TAPEMEDIA_HANDLER;
>typedef struct TAPEAUTOLOADENTRY TAPEAUTOLOADENTRY;
>typedef struct TAMDIR TAMDIR;
>
>
>
>
>
>typedef int DEVIF (DEVBLK *dev, int argc, char *argv[]);
>typedef void DEVQF (DEVBLK *dev, char **class, int buflen,
>                                   char *buffer);
>typedef void DEVXF (DEVBLK *dev, BYTE code, BYTE flags,
>                                   BYTE chained, U16 count,
>                                   BYTE prevcode, int ccwseq,
>                                   BYTE *iobuf, BYTE *more,
>                                   BYTE *unitstat, U16 *residual);
>typedef int DEVCF (DEVBLK *dev);
>typedef void DEVSF (DEVBLK *dev);
>typedef int DEVRF (DEVBLK *dev, int ix, BYTE *unitstat);
>typedef int DEVWF (DEVBLK *dev, int rcd, int off, BYTE *buf,
>                                   int len, BYTE *unitstat);
>typedef int DEVUF (DEVBLK *dev);
>typedef void DEVRR (DEVBLK *dev);
>typedef int DEVSA (DEVBLK *dev, U32 qmask);
>typedef int DEVSR (DEVBLK *dev, void *file);
>
>
>
>
>
>typedef BYTE *DEVIM;
># 228 "hstdinc.h" 2
># 31 "cpu.c" 2
># 40 "cpu.c"
># 1 "hercules.h" 1
>
>
>
>
>
>
>
># 1 "./config.h" 1
># 9 "hercules.h" 2
># 47 "hercules.h"
># 1 "feature.h" 1
>
>
>
>
># 1 "./config.h" 1
># 6 "feature.h" 2
>
>
>
># 1 "featall.h" 1
># 10 "feature.h" 2
># 1 "feat370.h" 1
># 11 "feature.h" 2
># 1 "feat390.h" 1
># 12 "feature.h" 2
># 1 "feat900.h" 1
># 13 "feature.h" 2
>
># 1 "featchk.h" 1
># 15 "feature.h" 2
># 26 "feature.h"
># 1 "featall.h" 1
># 27 "feature.h" 2
>
>
># 1 "feat370.h" 1
># 30 "feature.h" 2
># 38 "feature.h"
># 1 "featchk.h" 1
># 39 "feature.h" 2
># 48 "hercules.h" 2
>
>
>
>
>
># 1 "cpuint.h" 1
># 54 "hercules.h" 2
># 85 "hercules.h"
># 1 "linklist.h" 1
># 82 "linklist.h"
>typedef struct _LIST_ENTRY
>{
>    struct _LIST_ENTRY* Flink;
>    struct _LIST_ENTRY* Blink;
>}
>LIST_ENTRY, *PLIST_ENTRY;
># 86 "hercules.h" 2
># 1 "hconsts.h" 1
>
>
>
>
>
>
># 1 "hercules.h" 1
>
>
>
>
>
>
>
># 1 "./config.h" 1
># 9 "hercules.h" 2
># 47 "hercules.h"
># 1 "feature.h" 1
>
>
>
>
># 1 "./config.h" 1
># 6 "feature.h" 2
># 26 "feature.h"
># 1 "featall.h" 1
># 27 "feature.h" 2
>
>
># 1 "feat370.h" 1
># 30 "feature.h" 2
># 38 "feature.h"
># 1 "featchk.h" 1
># 39 "feature.h" 2
># 48 "hercules.h" 2
>
>
>
>
>
># 1 "cpuint.h" 1
># 54 "hercules.h" 2
># 8 "hconsts.h" 2
># 87 "hercules.h" 2
># 1 "hthreads.h" 1
>
>
>
>
>
>
>
># 1 "hercules.h" 1
>
>
>
>
>
>
>
># 1 "./config.h" 1
># 9 "hercules.h" 2
># 47 "hercules.h"
># 1 "feature.h" 1
>
>
>
>
># 1 "./config.h" 1
># 6 "feature.h" 2
># 26 "feature.h"
># 1 "featall.h" 1
># 27 "feature.h" 2
>
>
># 1 "feat370.h" 1
># 30 "feature.h" 2
># 38 "feature.h"
># 1 "featchk.h" 1
># 39 "feature.h" 2
># 48 "hercules.h" 2
>
>
>
>
>
># 1 "cpuint.h" 1
># 54 "hercules.h" 2
># 9 "hthreads.h" 2
># 56 "hthreads.h"
># 1 "/usr/include/pthread.h" 1 3 4
># 28 "/usr/include/pthread.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/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
>};
># 116 "/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
>};
># 157 "/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
>
>};
># 192 "/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
>
>};
># 230 "/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__ , __leaf__));
>
>
>
>
>
>
>
>extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
>     const struct timespec *__abstime);
>
>
>
>
>
>
>extern int pthread_detach (pthread_t __th) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>extern pthread_t pthread_self (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
>  __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
>
>
>
>
>
>
>
>extern int pthread_attr_init (pthread_attr_t *__attr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_destroy (pthread_attr_t *__attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
>     int *__detachstate)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
>     int __detachstate)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
>          size_t *__guardsize)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
>          size_t __guardsize)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
>           struct sched_param *__restrict __param)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
>           const struct sched_param *__restrict
>           __param) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
>     __attr, int *__restrict __policy)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
>      __attr, int *__restrict __inherit)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
>      int __inherit)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
>      int *__restrict __scope)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
>          __attr, void **__restrict __stackaddr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));
>
>
>
>
>
>extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
>          void *__stackaddr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));
>
>
>extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
>          __attr, size_t *__restrict __stacksize)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
>          size_t __stacksize)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
>      void **__restrict __stackaddr,
>      size_t *__restrict __stacksize)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>
>
>extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
>      size_t __stacksize) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
>     size_t __cpusetsize,
>     const cpu_set_t *__cpuset)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
>     size_t __cpusetsize,
>     cpu_set_t *__cpuset)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 3)));
>
>
>extern int pthread_getattr_default_np (pthread_attr_t *__attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_setattr_default_np (const pthread_attr_t *__attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>
>
>extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
>      const struct sched_param *__param)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3)));
>
>
>extern int pthread_getschedparam (pthread_t __target_thread,
>      int *__restrict __policy,
>      struct sched_param *__restrict __param)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3)));
>
>
>extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
>     __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
>          size_t __buflen)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>extern int pthread_getconcurrency (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int pthread_setconcurrency (int __level) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>
>
>
>extern int pthread_yield (void) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
>       const cpu_set_t *__cpuset)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3)));
>
>
>extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
>       cpu_set_t *__cpuset)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3)));
># 496 "/usr/include/pthread.h" 3 4
>extern int pthread_once (pthread_once_t *__once_control,
>    void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
># 508 "/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);
>
>
>
>
>typedef struct
>{
>  struct
>  {
>    __jmp_buf __cancel_jmp_buf;
>    int __mask_was_saved;
>  } __cancel_jmp_buf[1];
>  void *__pad[4];
>} __pthread_unwind_buf_t __attribute__ ((__aligned__));
># 542 "/usr/include/pthread.h" 3 4
>struct __pthread_cleanup_frame
>{
>  void (*__cancel_routine) (void *);
>  void *__cancel_arg;
>  int __do_it;
>  int __cancel_type;
>};
># 609 "/usr/include/pthread.h" 3 4
>extern __inline void
>__pthread_cleanup_routine (struct __pthread_cleanup_frame *__frame)
>{
>  if (__frame->__do_it)
>    __frame->__cancel_routine (__frame->__cancel_arg);
>}
># 744 "/usr/include/pthread.h" 3 4
>struct __jmp_buf_tag;
>extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern int pthread_mutex_init (pthread_mutex_t *__mutex,
>          const pthread_mutexattr_t *__mutexattr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
>     __attribute__ ((__nothrow__ , __leaf__)) __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)));
>
>
>
>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__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
>      int __prioceiling,
>      int *__restrict __old_ceiling)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>
>extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 808 "/usr/include/pthread.h" 3 4
>extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
>      __restrict __attr,
>      int *__restrict __pshared)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
>      int __pshared)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
>          __attr, int *__restrict __kind)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
>       __restrict __attr,
>       int *__restrict __protocol)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
>       int __protocol)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
>          __restrict __attr,
>          int *__restrict __prioceiling)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
>          int __prioceiling)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
>     int *__robustness)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr,
>        int *__robustness)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
>     int __robustness)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
>        int __robustness)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 890 "/usr/include/pthread.h" 3 4
>extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
>    const pthread_rwlockattr_t *__restrict
>    __attr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
>     __attribute__ ((__nothrow__ , __leaf__)) __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)));
>
>
>
>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)));
>
>
>
>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__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
>       __restrict __attr,
>       int *__restrict __pshared)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
>       int __pshared)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
>       __restrict __attr,
>       int *__restrict __pref)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
>       int __pref) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
>         const pthread_condattr_t *__restrict __cond_attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_cond_destroy (pthread_cond_t *__cond)
>     __attribute__ ((__nothrow__ , __leaf__)) __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)));
># 1002 "/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)));
>
>
>
>
>extern int pthread_condattr_init (pthread_condattr_t *__attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_condattr_getpshared (const pthread_condattr_t *
>     __restrict __attr,
>     int *__restrict __pshared)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
>     int __pshared) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_condattr_getclock (const pthread_condattr_t *
>          __restrict __attr,
>          __clockid_t *__restrict __clock_id)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
>          __clockid_t __clock_id)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 1046 "/usr/include/pthread.h" 3 4
>extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
>     __attribute__ ((__nothrow__ , __leaf__)) __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__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
>     __attribute__ ((__nothrow__ , __leaf__)) __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__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
>        __restrict __attr,
>        int *__restrict __pshared)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
>        int __pshared)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
># 1113 "/usr/include/pthread.h" 3 4
>extern int pthread_key_create (pthread_key_t *__key,
>          void (*__destr_function) (void *))
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_key_delete (pthread_key_t __key) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern void *pthread_getspecific (pthread_key_t __key) __attribute__ ((__nothrow__ , __leaf__));
>
>
>extern int pthread_setspecific (pthread_key_t __key,
>    const void *__pointer) __attribute__ ((__nothrow__ , __leaf__)) ;
>
>
>
>
>extern int pthread_getcpuclockid (pthread_t __thread_id,
>      __clockid_t *__clock_id)
>     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
># 1147 "/usr/include/pthread.h" 3 4
>extern int pthread_atfork (void (*__prepare) (void),
>      void (*__parent) (void),
>      void (*__child) (void)) __attribute__ ((__nothrow__ , __leaf__));
>
>
>
>
>extern __inline int
>__attribute__ ((__nothrow__ , __leaf__)) pthread_equal (pthread_t __thread1, pthread_t __thread2)
>{
>  return __thread1 == __thread2;
>}
>
>
>
># 57 "hthreads.h" 2
>
>typedef pthread_t TID;
>typedef pthread_mutex_t LOCK;
>typedef pthread_cond_t COND;
>typedef pthread_attr_t ATTR;
># 98 "hthreads.h"
>typedef void*THREAD_FUNC(void*);
># 118 "hthreads.h"
># 1 "pttrace.h" 1
># 52 "pttrace.h"
>extern int ptt_pthread_mutex_init(LOCK *, pthread_mutexattr_t *, char *);
>extern int ptt_pthread_mutex_lock(LOCK *, char *);
>extern int ptt_pthread_mutex_trylock(LOCK *, char *);
>extern int ptt_pthread_mutex_unlock(LOCK *, char *);
>extern int ptt_pthread_cond_init(COND *, pthread_condattr_t *, char *);
>extern int ptt_pthread_cond_signal(COND *, char *);
>extern int ptt_pthread_cond_broadcast(COND *, char *);
>extern int ptt_pthread_cond_wait(COND *, LOCK *, char *);
>extern int ptt_pthread_cond_timedwait(COND *, LOCK *, const struct timespec *, char *);
>extern int ptt_pthread_create(TID *, ATTR *, void *(*)(), void *, char *, char *);
>extern int ptt_pthread_join(TID, void **, char *);
>extern int ptt_pthread_detach(TID, char *);
>extern int ptt_pthread_kill(TID, int, char *);
>
>
>extern void ptt_trace_init (int n, int init);
>extern int ptt_cmd(int argc, char *argv[], char*cmdline);
>extern void ptt_pthread_trace (int, char *, void *, void *, char *, int);
>extern int ptt_pthread_print ();
>extern int pttclass;
>void *ptt_timeout();
>
>typedef struct _PTT_TRACE {
>        TID tid;
>        int class;
># 87 "pttrace.h"
>        char *type;
>        void *data1;
>        void *data2;
>        char *loc;
>        struct timeval tv;
>        int result;
>      } PTT_TRACE;
># 119 "hthreads.h" 2
># 88 "hercules.h" 2
># 1 "hmacros.h" 1
>
>
>
>
>
>
># 1 "hercules.h" 1
>
>
>
>
>
>
>
># 1 "./config.h" 1
># 9 "hercules.h" 2
># 47 "hercules.h"
># 1 "feature.h" 1
>
>
>
>
># 1 "./config.h" 1
># 6 "feature.h" 2
># 26 "feature.h"
># 1 "featall.h" 1
># 27 "feature.h" 2
>
>
># 1 "feat370.h" 1
># 30 "feature.h" 2
># 38 "feature.h"
># 1 "featchk.h" 1
># 39 "feature.h" 2
># 48 "hercules.h" 2
>
>
>
>
>
># 1 "cpuint.h" 1
># 54 "hercules.h" 2
># 8 "hmacros.h" 2
># 258 "hmacros.h"
>typedef void (__attribute__ (( regparm(2) ))*FUNC)();
>
>
>typedef void (__attribute__ (( regparm(2) )) *pi_func) (REGS *regs, int pcode);
>
>
>typedef U32 (*s390_trace_br_func) (int amode, U32 ia, REGS *regs);
>typedef U64 (*z900_trace_br_func) (int amode, U64 ia, REGS *regs);
># 89 "hercules.h" 2
># 102 "hercules.h"
># 1 "hostinfo.h" 1
># 15 "hostinfo.h"
># 1 "hercules.h" 1
>
>
>
>
>
>
>
># 1 "./config.h" 1
># 9 "hercules.h" 2
># 47 "hercules.h"
># 1 "feature.h" 1
>
>
>
>
># 1 "./config.h" 1
># 6 "feature.h" 2
># 26 "feature.h"
># 1 "featall.h" 1
># 27 "feature.h" 2
>
>
># 1 "feat370.h" 1
># 30 "feature.h" 2
># 38 "feature.h"
># 1 "featchk.h" 1
># 39 "feature.h" 2
># 48 "hercules.h" 2
>
>
>
>
>
># 1 "cpuint.h" 1
># 54 "hercules.h" 2
># 16 "hostinfo.h" 2
># 27 "hostinfo.h"
>typedef struct HOST_INFO
>{
>    char sysname[20];
>    char nodename[20];
>    char release[20];
>    char version[50];
>    char machine[20];
>    int trycritsec_avail;
>    int num_procs;
>} HOST_INFO;
>
>extern HOST_INFO hostinfo;
>extern void init_hostinfo ( HOST_INFO* pHostInfo );
>extern void display_hostinfo ( HOST_INFO* pHostInfo, FILE *f,int httpfd );
>extern char* get_hostinfo_str ( HOST_INFO* pHostInfo,
>                                       char* pszHostInfoStrBuff,
>                                       size_t nHostInfoStrBuffSiz );
># 103 "hercules.h" 2
># 1 "version.h" 1
># 14 "version.h"
># 1 "hercules.h" 1
>
>
>
>
>
>
>
># 1 "./config.h" 1
># 9 "hercules.h" 2
># 47 "hercules.h"
># 1 "feature.h" 1
>
>
>
>
># 1 "./config.h" 1
># 6 "feature.h" 2
># 26 "feature.h"
># 1 "featall.h" 1
># 27 "feature.h" 2
>
>
># 1 "feat370.h" 1
># 30 "feature.h" 2
># 38 "feature.h"
># 1 "featchk.h" 1
># 39 "feature.h" 2
># 48 "hercules.h" 2
>
>
>
>
>
># 1 "cpuint.h" 1
># 54 "hercules.h" 2
># 15 "version.h" 2
># 39 "version.h"
>extern void display_version(FILE *f, char *prog, const char verbose);
>extern void display_version_2(FILE *f, char *prog, const char verbose,int httpfd);
>extern int get_buildinfo_strings(const char*** pppszBldInfoStr);
># 104 "hercules.h" 2
>
># 1 "esa390.h" 1
># 36 "esa390.h"
> typedef union {
>                 U16 H;
>                 struct { BYTE L; BYTE H; } B;
>               } HW;
> typedef union {
>                 U32 F;
>                 struct { HW L; HW H; } H;
>                 struct { U32 A:24, B:8; } A;
>               } FW;
> typedef union {
>                 U64 D;
>                 struct { FW L; FW H; } F;
>               } DW;
> typedef union {
>                 struct { DW L; DW H; } D;
>                 struct { FW LL; FW LH; FW HL; FW HH; } F;
>               } QW;
>
>
>
>typedef union {
>                 HWORD H;
>                 struct { BYTE H; BYTE L; } B;
>               } HWORD_U;
>typedef union {
>                 FWORD F;
>                 struct { HWORD_U H; HWORD_U L; } H;
>               } FWORD_U;
>typedef union {
>                 DBLWRD D;
>                 struct { FWORD_U H; FWORD_U L; } F;
>               } DWORD_U;
>
>
>typedef struct _PSW {
>        BYTE sysmask;
>        BYTE pkey;
>        BYTE states;
>        BYTE asc;
>
>        BYTE cc;
>        BYTE progmask;
>        BYTE zerobyte;
>
>        u_int
>                 amode64:1,
>                 amode:1,
>                 zeroilc:1;
>        U32 zeroword;
>        DW ia;
>
>
>        DW amask;
>        U16 intcode;
>        BYTE ilc;
>        BYTE unused;
>    } PSW;
># 164 "esa390.h"
>typedef struct _TLB {
>        DW asd[1024];
>
>
>        DW vaddr[1024];
>
>
>        DW pte[1024];
>
>
>        BYTE *main[1024];
>        BYTE *storkey[1024];
>        BYTE skey[1024];
>        BYTE common[1024];
>        BYTE protect[1024];
>        BYTE acc[1024];
>    } TLB;
># 190 "esa390.h"
>typedef struct _DAT {
>        U64 raddr;
>        U64 aaddr;
>        U64 rpfra;
>        U64 asd;
>
>        int stid;
>        BYTE *storkey;
>        U16 xcode;
>        u_int private:1,
>                protect:2;
>      } DAT;
># 548 "esa390.h"
>typedef struct _LSED {
>        BYTE uet;
>        BYTE si;
>        HWORD rfs;
>        HWORD nes;
>        HWORD resv;
>    } LSED;
># 668 "esa390.h"
>typedef struct _PSA_3XX {
>        DBLWRD iplpsw;
>        DBLWRD iplccw1;
>        DBLWRD iplccw2;
>        DBLWRD extold;
>        DBLWRD svcold;
>        DBLWRD pgmold;
>        DBLWRD mckold;
>        DBLWRD iopold;
>        DBLWRD csw;
>        FWORD caw;
>        FWORD resv04C;
>        FWORD inttimer;
>        FWORD resv054;
>        DBLWRD extnew;
>        DBLWRD svcnew;
>        DBLWRD pgmnew;
>        DBLWRD mcknew;
>        DBLWRD iopnew;
>        FWORD extparm;
>        HWORD extcpad;
>        HWORD extint;
>        FWORD svcint;
>        FWORD pgmint;
>        FWORD tea;
>        HWORD monclass;
>        HWORD perint;
>        FWORD peradr;
>        FWORD moncode;
>        BYTE excarid;
>        BYTE perarid;
>        BYTE opndrid;
>        BYTE arch;
>        FWORD resv0A4;
>        FWORD chanid;
>        FWORD ioelptr;
>        FWORD lcl;
>        FWORD resv0B0;
>        FWORD ioid;
>        FWORD ioparm;
>        FWORD iointid;
>        FWORD resv0C4;
>        FWORD stfl;
>        FWORD resv0CC;
>        DBLWRD resv0D0;
>        DBLWRD storeptmr;
>        DBLWRD storeclkc;
>        DBLWRD mckint;
>        FWORD resv0F0;
>        FWORD xdmgcode;
>        FWORD mcstorad;
>        FWORD resv0FC;
>        DBLWRD storepsw;
>        FWORD storepfx;
>        FWORD resv10C;
>        DBLWRD resv110;
>        DBLWRD resv118;
>        FWORD storear[16];
>        FWORD storefpr[8];
>        FWORD storegpr[16];
>        FWORD storecr[16];
>} PSA_3XX;
>
>
>typedef struct _PSA_900 {
>         DBLWRD iplpsw;
>         DBLWRD iplccw1;
>         DBLWRD iplccw2;
>         BYTE resv0018[104];
>         FWORD extparm;
>         HWORD extcpad;
>         HWORD extint;
>         FWORD svcint;
>         FWORD pgmint;
>         FWORD dataexc;
>         HWORD monclass;
>         HWORD perint;
>         DBLWRD peradr;
>         BYTE excarid;
>         BYTE perarid;
>         BYTE opndrid;
>         BYTE arch;
>         FWORD mpladdr;
>         DWORD_U tea;
>
>
>
>         DBLWRD moncode;
>         FWORD ioid;
>         FWORD ioparm;
>         FWORD iointid;
>         FWORD resv00C0;
>         FWORD stfl;
>         FWORD resv00CC;
>         DBLWRD resv00D0;
>         DBLWRD resv00D8;
>         DBLWRD resv00E0;
>         DBLWRD mckint;
>         FWORD mckext;
>         FWORD xdmgcode;
>         DBLWRD mcstorad;
>         DBLWRD cao;
>         FWORD cal;
>         FWORD ec;
>         DBLWRD bea;
>         DBLWRD resv0118;
>         QWORD rstold;
>         QWORD extold;
>         QWORD svcold;
>         QWORD pgmold;
>         QWORD mckold;
>         QWORD iopold;
>         BYTE resv0180[32];
>         QWORD rstnew;
>         QWORD extnew;
>         QWORD svcnew;
>         QWORD pgmnew;
>         QWORD mcknew;
>         QWORD iopnew;
>         BYTE resv0200[4096];
>         FWORD storefpr[32];
>         DBLWRD storegpr[16];
>         QWORD storepsw;
>         DBLWRD resv1310;
>         FWORD storepfx;
>         FWORD storefpc;
>         FWORD resv1320;
>         FWORD storetpr;
>         DBLWRD storeptmr;
>         DBLWRD storeclkc;
>         DBLWRD resv1338;
>         FWORD storear[16];
>         DBLWRD storecr[16];
>} PSA_900;
># 978 "esa390.h"
>typedef struct _ORB {
>        FWORD intparm;
>        BYTE flag4;
>        BYTE flag5;
>        BYTE lpm;
>        BYTE flag7;
>        FWORD ccwaddr;
>    } ORB;
># 1011 "esa390.h"
>typedef struct _PMCW {
>        FWORD intparm;
>        BYTE flag4;
>        BYTE flag5;
>        HWORD devnum;
>        BYTE lpm;
>        BYTE pnom;
>        BYTE lpum;
>        BYTE pim;
>        HWORD mbi;
>        BYTE pom;
>        BYTE pam;
>        BYTE chpid[8];
>        BYTE zone;
>        BYTE flag25;
>        BYTE flag26;
>        BYTE flag27;
>    } PMCW;
># 1066 "esa390.h"
>typedef struct _ESW {
>        BYTE scl0;
>        BYTE lpum;
>        BYTE scl2;
>        BYTE scl3;
>        BYTE erw0;
>        BYTE erw1;
>        BYTE erw2;
>        BYTE erw3;
>        FWORD failaddr;
>        FWORD resv2;
>        FWORD resv3;
>    } ESW;
># 1125 "esa390.h"
>typedef struct _SCSW {
>        BYTE flag0;
>        BYTE flag1;
>        BYTE flag2;
>        BYTE flag3;
>        FWORD ccwaddr;
>        BYTE unitstat;
>        BYTE chanstat;
>        HWORD count;
>    } SCSW;
># 1239 "esa390.h"
>typedef struct _SCHIB {
>        PMCW pmcw;
>        SCSW scsw;
>        BYTE moddep[12];
>    } SCHIB;
>
>
>typedef struct _IRB {
>        SCSW scsw;
>        ESW esw;
>        BYTE ecw[32];
>    } IRB;
>
>
>typedef struct _MBK {
>        HWORD srcount;
>        HWORD samplecnt;
>        FWORD dct;
>        FWORD fpt;
>        FWORD ddt;
>        FWORD cuqt;
>        FWORD resv[3];
>    } MBK;
># 1456 "esa390.h"
>typedef struct _SIE1BK {
>        BYTE v;
>
>
>
>
>
>
>        BYTE s;
>
>
>
>
>
>        BYTE mx;
>
>
>
>        BYTE m;
>
>
>
>
>
>
>
>        FWORD prefix;
>        HWORD mso;
>        HWORD mse;
>        FWORD resv0cf;
>        FWORD gr14;
>        FWORD gr15;
>        DBLWRD psw;
>        FWORD resv20f;
>        FWORD residue;
>        DBLWRD cputimer;
>        DBLWRD clockcomp;
>        DBLWRD epoch;
>        FWORD svc_ctl;
>
>
>
>
>
>        HWORD lctl_ctl;
># 1519 "esa390.h"
>        HWORD cpuad;
>        FWORD ic;
># 1555 "esa390.h"
>        FWORD ec;
># 1571 "esa390.h"
>        BYTE c;
># 1586 "esa390.h"
>        BYTE f;
>
>
>
>
>        HWORD lhcpu;
>        HWORD todpf;
>        HWORD ipa;
>        FWORD ipb;
>        FWORD ipc;
>        FWORD rcpo;
>
>
>
>
>
>        FWORD scao;
>        FWORD subchtabo;
>        FWORD resv6Cf;
>        HWORD tch_ctl;
>        HWORD resv72h;
>        BYTE zone;
>        BYTE resv075;
>        BYTE tschds;
>        BYTE tschsc;
>        BYTE xslim[3];
>        BYTE resv7Bb;
>        FWORD resv7Cf;
>        FWORD cr[16];
>        BYTE ip[34];
>
>
>
>
>
>
>        BYTE xso[3];
>        BYTE xsl[3];
>        BYTE resvE8b[24];
>} SIE1BK;
>
>
>typedef struct _SIE2BK {
>        BYTE v;
>
>
>
>
>
>
>        BYTE s;
>
>
>
>
>
>        BYTE mx;
>
>
>
>
>        BYTE m;
>
>
>
>
>
>
>
>        FWORD prefix;
>        FWORD resv008f;
>        FWORD resv00cf;
>        DBLWRD resv010d;
>        DBLWRD resv018d;
>        DBLWRD resv020d;
>        DBLWRD cputimer;
>        DBLWRD clockcomp;
>        DBLWRD epoch;
>        FWORD svc_ctl;
>
>
>
>
>
>        HWORD lctl_ctl;
># 1689 "esa390.h"
>        HWORD cpuad;
>        FWORD ic;
># 1724 "esa390.h"
>        FWORD ec;
># 1740 "esa390.h"
>        BYTE c;
># 1753 "esa390.h"
>        BYTE f;
>
>
>
>
>        HWORD lhcpu;
>        HWORD resv054h;
>        HWORD ipa;
>
>
>
>
>        FWORD ipb;
>        FWORD ipc;
>        FWORD rcpo;
>
>
>
>
>
>        FWORD scao;
>        FWORD resv068f;
>        HWORD todpfh;
>        HWORD todpf;
>        FWORD resv070f;
>        BYTE zone;
>        BYTE resv075;
>        BYTE tschds;
>        BYTE tschsc;
>        FWORD resv078f;
>        FWORD resv07cf;
>        DBLWRD mso;
>        DBLWRD mse;
>
>
>
>        QWORD psw;
>        DBLWRD gr14;
>        DBLWRD gr15;
>        DBLWRD recv0b0d;
>        HWORD recv0b8d;
>        BYTE xso[3];
>        BYTE xsl[3];
>        BYTE ip[52];
>
>
>
>
>
>
>        BYTE resv0f4b[6];
>        HWORD ief;
>        FWORD resv0fcf;
>        DBLWRD cr[16];
>        BYTE resv180b[128];
>} SIE2BK;
># 1918 "esa390.h"
>typedef struct _ZPB1 {
>        FWORD mso;
>
>        FWORD msl;
>
>        FWORD eso;
>
>        FWORD esl;
>
>        FWORD res[4];
>} ZPB1;
>
>typedef struct _ZPB2 {
>        DBLWRD mso;
>
>        DBLWRD msl;
>
>
>        DBLWRD eso;
>
>        DBLWRD esl;
>
>
>} ZPB2;
>
>typedef struct _SCAENT {
>        FWORD scn;
>        FWORD resv1;
>        DBLWRD sda;
>        DBLWRD resv2[2];
>} SCAENT;
>
>typedef struct _SCABLK {
>        DBLWRD ipte_control;
>        DBLWRD resv1[5];
>        DBLWRD mcn;
>        DBLWRD resv2;
>        SCAENT vcpu[64];
>} SCABLK;
># 1973 "esa390.h"
>typedef struct _SYSIB111 {
>        BYTE flag1;
>
>        BYTE resv1[3];
>        FWORD resv2[7];
>        BYTE manufact[16];
>        BYTE type[4];
>        FWORD resv3[3];
>        BYTE modcapaid[16];
>        BYTE seqc[16];
>        BYTE plant[4];
>        BYTE model[16];
>        BYTE mpci[16];
>        BYTE mtci[16];
>        FWORD mcaprating;
>        FWORD mpcaprating;
>        FWORD mtcaprating;
>        BYTE typepct[5];
>    } SYSIB111;
>
>typedef struct _SYSIB121 {
>        FWORD resv1[20];
>        BYTE seqc[16];
>        BYTE plant[4];
>        HWORD resv2;
>        HWORD cpuad;
>    } SYSIB121;
>
>typedef struct _SYSIB122 {
>        BYTE format;
>        BYTE resv1;
>        HWORD accoff;
>        FWORD resv2[6];
>        FWORD sccap;
>        FWORD cap;
>        HWORD totcpu;
>        HWORD confcpu;
>        HWORD sbcpu;
>        HWORD resvcpu;
>        HWORD mpfact[8 -1];
>
>        HWORD resv3;
>
>        FWORD accap;
>        HWORD ampfact[8 -1];
>
>        HWORD resv4;
>
>    } SYSIB122;
>
>typedef struct _SYSIB221 {
>        FWORD resv1[20];
>        BYTE seqc[16];
>        BYTE plant[4];
>        HWORD lcpuid;
>        HWORD cpuad;
>    } SYSIB221;
>
>typedef struct _SYSIB222 {
>        FWORD resv1[8];
>        HWORD lparnum;
>        BYTE resv2;
>        BYTE lcpuc;
>
>
>
>        HWORD totcpu;
>        HWORD confcpu;
>        HWORD sbcpu;
>        HWORD resvcpu;
>        BYTE lparname[8];
>        FWORD lparcaf;
>        FWORD mdep[2];
>        FWORD resv3[2];
>        HWORD dedcpu;
>        HWORD shrcpu;
>    } SYSIB222;
>
>typedef struct _SYSIB322 {
>        BYTE resv1[4*7];
>        BYTE resv2[3*1];
>        BYTE dbct;
>        BYTE vmdb[4*16];
>    } SYSIB322;
>
>typedef struct _SYSIB1512 {
>        HWORD resv1;
>        HWORD len;
>        BYTE mag[6];
>        BYTE resv2;
>        BYTE mnest;
>        FWORD resv3;
>        BYTE tles[];
>    } SYSIB1512;
>
>typedef struct _TLECNTNR {
>        BYTE nl;
>        BYTE resv1[3];
>        BYTE resv2;
>        BYTE resv3[2];
>        BYTE cntnrid;
>    } TLECNTNR;
>
>typedef struct _TLECPU {
>        BYTE nl;
>        BYTE resv1[3];
>        BYTE flags;
>        BYTE cputype;
>        U16 cpuadorg;
>        DW cpumask;
>    } TLECPU;
># 2092 "esa390.h"
>typedef struct _SYSIBVMDB {
>        BYTE resv1[4*1];
>        HWORD totcpu;
>        HWORD confcpu;
>        HWORD sbcpu;
>        HWORD resvcpu;
>        BYTE vmname[8];
>        FWORD vmcaf;
>        BYTE cpid[4*4];
>    } SYSIBVMDB;
># 2114 "esa390.h"
>typedef struct _PTFFQAF {
>        FWORD sb[4];
>    } PTFFQAF;
>
>typedef struct _PTFFQTO {
>        DBLWRD physclk;
>        DBLWRD todoff;
>        DBLWRD ltodoff;
>        DBLWRD todepoch;
>    } PTFFQTO;
>
>typedef struct _PTFFQSI {
>        DBLWRD physclk;
>        DBLWRD oldestart;
>        DBLWRD oldebase;
>        FWORD oldfsr;
>        FWORD oldgsr;
>        DBLWRD newestart;
>        DBLWRD newebase;
>        FWORD newfsr;
>        FWORD newgsr;
>    } PTFFQSI;
># 106 "hercules.h" 2
># 1 "hscutl.h" 1
># 13 "hscutl.h"
># 1 "hercules.h" 1
>
>
>
>
>
>
>
># 1 "./config.h" 1
># 9 "hercules.h" 2
># 47 "hercules.h"
># 1 "feature.h" 1
>
>
>
>
># 1 "./config.h" 1
># 6 "feature.h" 2
># 26 "feature.h"
># 1 "featall.h" 1
># 27 "feature.h" 2
>
>
># 1 "feat370.h" 1
># 30 "feature.h" 2
># 38 "feature.h"
># 1 "featchk.h" 1
># 39 "feature.h" 2
># 48 "hercules.h" 2
>
>
>
>
>
># 1 "cpuint.h" 1
># 54 "hercules.h" 2
># 14 "hscutl.h" 2
># 59 "hscutl.h"
>  char *hostpath( char *outpath, const char *inpath, size_t buffsize );
>
>
>
>  int get_file_accmode_flags( int fd );
>
>
>  int socket_init( void );
>  int socket_deinit( void );
>
>
>  int socket_set_blocking_mode( int sfd, int blocking_mode );
>
>
>
>  int socket_is_socket( int sfd );
>
>
>
>  void socket_keepalive( int sfd, int idle_time, int probe_interval,
>                         int probe_count );
># 91 "hscutl.h"
>  extern void set_symbol(const char *,const char *);
>  extern const char *get_symbol(const char *);
>  extern char *resolve_symbol_string(const char *);
>  extern void kill_all_symbols(void);
>  extern void list_all_symbols(void);
># 147 "hscutl.h"
>extern size_t
>strlcpy(char *dst, const char *src, size_t siz);
># 168 "hscutl.h"
>extern size_t
>strlcat(char *dst, const char *src, size_t siz);
>
>
>
>extern int timeval_subtract (struct timeval *beg_timeval, struct timeval *end_timeval, struct timeval *dif_timeval);
>extern int timeval_add (struct timeval *dif_timeval, struct timeval *accum_timeval);
>
>
>
>
>
>
>extern int timed_wait_condition_relative_usecs
>(
>    COND* pCOND,
>    LOCK* pLOCK,
>    U32 usecs,
>    struct timeval* pTV
>);
>
>
>extern void cause_crash();
>
>
>extern int hprintf(int s,char *fmt,...);
>extern int hwrite(int s,const char *,size_t);
>extern int hgetc(int s);
>extern char *hgets(char *b,size_t c,int s);
>
>
>
>extern int hopen(const char* path, int oflag, ...);
># 107 "hercules.h" 2
># 1 "w32util.h" 1
># 108 "hercules.h" 2
># 1 "clock.h" 1
># 16 "clock.h"
>typedef struct _CSR {
>    U64 start_time;
>    S64 base_offset;
>    S32 fine_s_rate;
>    S32 gross_s_rate;
>} CSR;
>
>
>void csr_reset(void);
>void set_tod_steering(double);
>double get_tod_steering(void);
>U64 update_tod_clock(void);
>void update_cpu_timer(void);
>void set_tod_epoch(S64);
>void adjust_tod_epoch(S64);
>S64 get_tod_epoch(void);
>U64 hw_clock(void);
>S64 cpu_timer(REGS *);
>void set_cpu_timer(REGS *, S64);
>S32 int_timer(REGS *);
>void set_int_timer(REGS *, S32);
>U64 tod_clock(REGS *);
>void set_tod_clock(U64);
>int chk_int_timer(REGS *);
>int clock_hsuspend(void *file);
>int clock_hresume(void *file);
>
>static __inline__ U64 host_tod(void)
>{
>    struct timeval tv;
>    gettimeofday (&tv, ((void *)0));
>    return (U64)tv.tv_sec*1000000 + tv.tv_usec;
>}
>
>
>
> void s370_store_int_timer (REGS *);
>void s370_store_int_timer_nolock (REGS *);
> void s370_fetch_int_timer (REGS *);
>
>void s370_set_gross_s_rate (REGS *);
>void s370_set_fine_s_rate (REGS *);
>void s370_set_tod_offset (REGS *);
>void s370_adjust_tod_offset (REGS *);
>void s370_query_physical_clock (REGS *);
>void s370_query_steering_information (REGS *);
>void s370_query_tod_offset (REGS *);
>void s370_query_available_functions (REGS *);
>
>
>extern U64 tod_value;
>
>
>extern S64 tod_epoch;
>
>
>extern U64 hw_tod;
># 109 "hercules.h" 2
>
># 1 "codepage.h" 1
>
>
>
>
>
>
># 1 "hercules.h" 1
>
>
>
>
>
>
>
># 1 "./config.h" 1
># 9 "hercules.h" 2
># 47 "hercules.h"
># 1 "feature.h" 1
>
>
>
>
># 1 "./config.h" 1
># 6 "feature.h" 2
># 26 "feature.h"
># 1 "featall.h" 1
># 27 "feature.h" 2
>
>
># 1 "feat370.h" 1
># 30 "feature.h" 2
># 38 "feature.h"
># 1 "featchk.h" 1
># 39 "feature.h" 2
># 48 "hercules.h" 2
>
>
>
>
>
># 1 "cpuint.h" 1
># 54 "hercules.h" 2
># 8 "codepage.h" 2
># 20 "codepage.h"
>extern void set_codepage(char *name);
>extern unsigned char host_to_guest (unsigned char byte);
>extern unsigned char guest_to_host (unsigned char byte);
># 111 "hercules.h" 2
># 1 "logger.h" 1
># 30 "logger.h"
>extern int logger_syslogfd[2];
># 42 "logger.h"
>extern void logmsg(char *,...);
>extern void logmsgp(char *,...);
>extern void logmsgb(char *,...);
>extern void logdevtr(DEVBLK *dev, char *, ...);
>
>extern void logger_init(void);
>
>extern int log_read(char **buffer, int *msgindex, int block);
>extern int log_line(int linenumber);
>extern void log_sethrdcpy(char *filename);
>extern void log_wakeup(void *arg);
>
>
>typedef void LOG_WRITER(void *,char *);
>typedef void LOG_CLOSER(void *);
>
>extern int log_open(LOG_WRITER*,LOG_CLOSER*,void *);
>extern void log_close(void);
>extern void log_write(int,char *);
>
>
>
>extern char *log_capture(void *(*)(void *),void *);
># 112 "hercules.h" 2
># 1 "hdl.h" 1
>
>
>
>
>
>
># 1 "hercules.h" 1
>
>
>
>
>
>
>
># 1 "./config.h" 1
># 9 "hercules.h" 2
># 47 "hercules.h"
># 1 "feature.h" 1
>
>
>
>
># 1 "./config.h" 1
># 6 "feature.h" 2
># 26 "feature.h"
># 1 "featall.h" 1
># 27 "feature.h" 2
>
>
># 1 "feat370.h" 1
># 30 "feature.h" 2
># 38 "feature.h"
># 1 "featchk.h" 1
># 39 "feature.h" 2
># 48 "hercules.h" 2
>
>
>
>
>
># 1 "cpuint.h" 1
># 54 "hercules.h" 2
># 8 "hdl.h" 2
># 40 "hdl.h"
>struct _HDLSHD;
>typedef struct _HDLSHD {
>    struct _HDLSHD *next;
>    char* shdname;
>    void (*shdcall) (void *);
>    void *shdarg;
>} HDLSHD;
>
>extern void hdl_adsc(char*, void *, void *);
>extern int hdl_rmsc(void *, void *);
>extern void hdl_shut(void);
> DEVHND *hdl_ghnd(const char *devname);
># 86 "hdl.h"
>typedef struct _HDLDEV {
>    char *name;
>    DEVHND *hnd;
>    struct _HDLDEV *next;
>} HDLDEV;
>
>
>typedef struct _HDLINS {
>    int opcode;
>    int archflags;
>    char *instname;
>    void *instruction;
>    void *original;
>    struct _HDLINS *next;
>} HDLINS;
>
>
>struct _HDLDEP;
>typedef struct _HDLDEP {
>    char *name;
>    char *version;
>    int size;
>    struct _HDLDEP *next;
>} HDLDEP;
>
>
>typedef struct _HDLPRE {
>    char *name;
>    int flag;
>} HDLPRE;
>
>
>struct _MODENT;
>typedef struct _MODENT {
>    void (*fep)();
>    char *name;
>    int count;
>    struct _MODENT *modnext;
>} MODENT;
>
>
>struct _DLLENT;
>typedef struct _DLLENT {
>    char *name;
>    void *dll;
>    int flags;
>    int (*hdldepc)(void *);
>    int (*hdlreso)(void *);
>    int (*hdlinit)(void *);
>    int (*hdlddev)(void *);
>    int (*hdldins)(void *);
>    int (*hdlfini)();
>    struct _MODENT *modent;
>    struct _HDLDEV *hndent;
>    struct _HDLINS *insent;
>    struct _DLLENT *dllnext;
>} DLLENT;
># 172 "hdl.h"
>
>int hdl_load(char *, int);
># 186 "hdl.h"
>
>int hdl_dele(char *);
>
>void hdl_list(int);
>
>
>
>void hdl_dlst();
>
>
>void hdl_main();
>
>
>void hdl_setpath(char *);
>
>
>void * hdl_fent(char *);
>
>void * hdl_nent(void *);
>
>
>static void **unresolved __attribute__ ((unused)) = ((void *)0);
># 113 "hercules.h" 2
>
># 1 "cache.h" 1
># 157 "cache.h"
># 1 "hercules.h" 1
>
>
>
>
>
>
>
># 1 "./config.h" 1
># 9 "hercules.h" 2
># 47 "hercules.h"
># 1 "feature.h" 1
>
>
>
>
># 1 "./config.h" 1
># 6 "feature.h" 2
># 26 "feature.h"
># 1 "featall.h" 1
># 27 "feature.h" 2
>
>
># 1 "feat370.h" 1
># 30 "feature.h" 2
># 38 "feature.h"
># 1 "featchk.h" 1
># 39 "feature.h" 2
># 48 "hercules.h" 2
>
>
>
>
>
># 1 "cpuint.h" 1
># 54 "hercules.h" 2
># 158 "cache.h" 2
># 258 "cache.h"
>int cache_nbr(int ix);
>int cache_busy(int ix);
>int cache_empty(int ix);
>int cache_waiters(int ix);
>long long cache_size(int ix);
>long long cache_hits(int ix);
>long long cache_misses(int ix);
>int cache_busy_percent(int ix);
>int cache_empty_percent(int ix);
>int cache_hit_percent(int ix);
>int cache_lookup(int ix, U64 key, int *o);
>typedef int CACHE_SCAN_RTN (int *answer, int ix, int i, void *data);
>int cache_scan (int ix, CACHE_SCAN_RTN rtn, void *data);
>int cache_lock(int ix);
>int cache_unlock(int ix);
>int cache_wait(int ix);
>U64 cache_getkey(int ix, int i);
>U64 cache_setkey(int ix, int i, U64 key);
>U32 cache_getflag(int ix, int i);
>U32 cache_setflag(int ix, int i, U32 andbits, U32 orbits);
>U64 cache_getage(int ix, int i);
>U64 cache_setage(int ix, int i);
>void *cache_getbuf(int ix, int i, int len);
>void *cache_setbuf(int ix, int i, void *buf, int len);
>int cache_getlen(int ix, int i);
>int cache_getval(int ix, int i);
>int cache_setval(int ix, int i, int val);
>int cache_release(int ix, int i, int flag);
>extern int cache_cmd(int argc, char *argv[], char *cmdline);
># 115 "hercules.h" 2
>
># 1 "devtype.h" 1
># 29 "devtype.h"
>struct DEVHND {
>        DEVIF *init;
>        DEVXF *exec;
>        DEVCF *close;
>        DEVQF *query;
>        DEVSF *start;
>        DEVSF *end;
>        DEVSF *resume;
>        DEVSF *suspend;
>        DEVRF *read;
>        DEVWF *write;
>        DEVUF *used;
>        DEVRR *reserve;
>        DEVRR *release;
>        DEVRR *attention;
>        DEVIM immed;
>        DEVSA *siga_r;
>        DEVSA *siga_w;
>        DEVSR *hsuspend;
>        DEVSR *hresume;
>};
># 65 "devtype.h"
>extern DEVHND ckddasd_device_hndinfo;
>extern DEVHND fbadasd_device_hndinfo;
>extern DEVHND ctcadpt_device_hndinfo;
>extern DEVHND ctci_device_hndinfo;
>extern DEVHND ctct_device_hndinfo;
>extern DEVHND lcs_device_hndinfo;
>extern DEVHND vmnet_device_hndinfo;
># 117 "hercules.h" 2
># 1 "dasdtab.h" 1
># 14 "dasdtab.h"
># 1 "hercules.h" 1
>
>
>
>
>
>
>
># 1 "./config.h" 1
># 9 "hercules.h" 2
># 47 "hercules.h"
># 1 "feature.h" 1
>
>
>
>
># 1 "./config.h" 1
># 6 "feature.h" 2
># 26 "feature.h"
># 1 "featall.h" 1
># 27 "feature.h" 2
>
>
># 1 "feat370.h" 1
># 30 "feature.h" 2
># 38 "feature.h"
># 1 "featchk.h" 1
># 39 "feature.h" 2
># 48 "hercules.h" 2
>
>
>
>
>
># 1 "cpuint.h" 1
># 54 "hercules.h" 2
># 15 "dasdtab.h" 2
># 47 "dasdtab.h"
>typedef struct _CKDDEV {
>        char *name;
>        U16 devt;
>        BYTE model;
>        BYTE class;
>        BYTE code;
>        U16 cyls;
>        U16 altcyls;
>        U16 heads;
>        U16 r0;
>        U16 r1;
>        U16 har0;
>        U16 len;
>        U16 sectors;
>        U16 rpscalc;
>        S16 formula;
>        U16 f1,f2,f3,f4,f5,f6;
>        char *cu;
>      } CKDDEV;
>
>
>
>
>
>typedef struct _CKDCU {
>        char *name;
>        U16 devt;
>        BYTE model;
>        BYTE code;
>        BYTE funcfeat;
>        BYTE typecode;
>        U32 sctlfeat;
>        U32 ciw1;
>        U32 ciw2;
>        U32 ciw3;
>        U32 ciw4;
>        U32 ciw5;
>        U32 ciw6;
>        U32 ciw7;
>        U32 ciw8;
>        U8 senselength;
>      } CKDCU;
>
>
>
>
>
>typedef struct _FBADEV {
>        char *name;
>        U16 devt;
>        BYTE class;
>        BYTE type;
>        BYTE model;
>        U32 bpg;
>        U32 bpp;
>        U32 size;
>        U32 blks;
>        U16 cu;
>      } FBADEV;
>
>
>
>
>
>
>typedef struct _BLKTAB {
>        char *name;
>        U16 devt;
>        int darch;
>
>
>
>        int phys512;
>        int phys1024;
>        int phys2048;
>        int phys4096;
>    } BLKTAB;
># 146 "dasdtab.h"
>extern void *dasd_lookup (int, char *, U32 , U32 );
>int dasd_build_ckd_devid (CKDDEV *, CKDCU *, BYTE *);
>int dasd_build_ckd_devchar (CKDDEV *, CKDCU *, BYTE *, int);
>extern int dasd_build_ckd_config_data (DEVBLK *, BYTE *, int);
>extern int dasd_build_ckd_subsys_status (DEVBLK *, BYTE *, int);
>int dasd_build_fba_devid (FBADEV *, BYTE *);
>int dasd_build_fba_devchar (FBADEV *, BYTE *, int);
># 118 "hercules.h" 2
># 1 "shared.h" 1
># 319 "shared.h"
># 1 "hercules.h" 1
>
>
>
>
>
>
>
># 1 "./config.h" 1
># 9 "hercules.h" 2
># 47 "hercules.h"
># 1 "feature.h" 1
>
>
>
>
># 1 "./config.h" 1
># 6 "feature.h" 2
># 26 "feature.h"
># 1 "featall.h" 1
># 27 "feature.h" 2
>
>
># 1 "feat370.h" 1
># 30 "feature.h" 2
># 38 "feature.h"
># 1 "featchk.h" 1
># 39 "feature.h" 2
># 48 "hercules.h" 2
>
>
>
>
>
># 1 "cpuint.h" 1
># 54 "hercules.h" 2
># 320 "shared.h" 2
># 345 "shared.h"
>typedef char SHRD_TRACE[128];
>
># 1 "hercules.h" 1
>
>
>
>
>
>
>
># 1 "./config.h" 1
># 9 "hercules.h" 2
># 47 "hercules.h"
># 1 "feature.h" 1
>
>
>
>
># 1 "./config.h" 1
># 6 "feature.h" 2
># 26 "feature.h"
># 1 "featall.h" 1
># 27 "feature.h" 2
>
>
># 1 "feat370.h" 1
># 30 "feature.h" 2
># 38 "feature.h"
># 1 "featchk.h" 1
># 39 "feature.h" 2
># 48 "hercules.h" 2
>
>
>
>
>
># 1 "cpuint.h" 1
># 54 "hercules.h" 2
># 348 "shared.h" 2
># 409 "shared.h"
>struct SHRD {
>        int id;
>        int fd;
>        char *ipaddr;
>        time_t time;
>        int release;
>        int comp;
>        int comps;
>        int pending:1,
>                waiting:1,
>                havehdr:1,
>                disconnect:1;
>        DBLWRD hdr;
>        int purgen;
>        FWORD purge[16];
>};
>
>typedef struct _SHRD_HDR {
>        BYTE cmd;
>        BYTE code;
>        U16 devnum;
>        U16 id;
>        U16 len;
>} SHRD_HDR;
># 456 "shared.h"
>int shared_update_notify (DEVBLK *dev, int block);
>int shared_ckd_init (DEVBLK *dev, int argc, char *argv[] );
>int shared_fba_init (DEVBLK *dev, int argc, char *argv[] );
>extern void *shared_server (void *arg);
>extern int shared_cmd(int argc, char *argv[], char *cmdline);
># 119 "hercules.h" 2
># 1 "hetlib.h" 1
># 18 "hetlib.h"
># 1 "hercules.h" 1
>
>
>
>
>
>
>
># 1 "./config.h" 1
># 9 "hercules.h" 2
># 47 "hercules.h"
># 1 "feature.h" 1
>
>
>
>
># 1 "./config.h" 1
># 6 "feature.h" 2
># 26 "feature.h"
># 1 "featall.h" 1
># 27 "feature.h" 2
>
>
># 1 "feat370.h" 1
># 30 "feature.h" 2
># 38 "feature.h"
># 1 "featchk.h" 1
># 39 "feature.h" 2
># 48 "hercules.h" 2
>
>
>
>
>
># 1 "cpuint.h" 1
># 54 "hercules.h" 2
># 19 "hetlib.h" 2
># 42 "hetlib.h"
>typedef struct _hethdr
>{
>    uint8_t clen[ 2 ];
>    uint8_t plen[ 2 ];
>    uint8_t flags1;
>    uint8_t flags2;
>} HETHDR;
># 75 "hetlib.h"
>typedef struct _hetb
>{
>    FILE *fd;
>    uint32_t chksize;
>    uint32_t ublksize;
>    uint32_t cblksize;
>    uint32_t cblk;
>    HETHDR chdr;
>    u_int writeprotect:1;
>    u_int readlast:1;
>    u_int truncated:1;
>    u_int compress:1;
>    u_int decompress:1;
>    u_int method:2;
>    u_int level:4;
>} HETB;
># 174 "hetlib.h"
>extern int het_open( HETB **hetb, char *filename, int flags );
>extern int het_close( HETB **hetb );
>extern int het_read_header( HETB *hetb );
>extern int het_read( HETB *hetb, void *sbuf );
>extern int het_write_header( HETB *hetb, int len, int flags1, int flags2 );
>extern int het_write( HETB *hetb, void *sbuf, int slen );
>extern int het_tapemark( HETB *hetb );
>extern int het_sync( HETB *hetb );
>extern int het_cntl( HETB *hetb, int func, unsigned long val );
>extern int het_locate( HETB *hetb, int block );
>extern int het_bsb( HETB *hetb );
>extern int het_fsb( HETB *hetb );
>extern int het_bsf( HETB *hetb );
>extern int het_fsf( HETB *hetb );
>extern int het_rewind( HETB *hetb );
>extern const char *het_error( int rc );
>extern off_t het_tell ( HETB *hetb );
># 120 "hercules.h" 2
># 1 "sockdev.h" 1
># 22 "sockdev.h"
>typedef int (*ONCONNECT)( DEVBLK* );
>
>
>
>
>
>struct bind_struct
>{
>    LIST_ENTRY bind_link;
>
>    DEVBLK *dev;
>    char *spec;
>    int sd;
>
>
>    char *clientname;
>    char *clientip;
>
>    ONCONNECT fn;
>    void *arg;
>};
>
>
>
>extern int bind_device_ex (DEVBLK* dev, char* spec, ONCONNECT fn, void* arg );
>extern int unbind_device_ex (DEVBLK* dev, int forced);
>
>static inline int bind_device (DEVBLK* dev, char* spec) { return bind_device_ex ( dev, spec, ((void *)0), ((void *)0) ); }
>static inline int unbind_device (DEVBLK* dev) { return unbind_device_ex ( dev, 0 ); }
># 121 "hercules.h" 2
># 1 "w32ctca.h" 1
># 122 "hercules.h" 2
>
># 1 "service.h" 1
># 36 "service.h"
>typedef struct _SCCB_HEADER {
>        HWORD length;
>        BYTE flag;
>        BYTE resv1[2];
>        BYTE type;
>        BYTE reas;
>        BYTE resp;
>    } SCCB_HEADER;
># 90 "service.h"
>typedef struct _SCCB_SCP_INFO {
>        HWORD realinum;
>
>        BYTE realiszm;
>
>        BYTE realbszk;
>
>        HWORD realiint;
>
>        HWORD resv2;
>        HWORD numcpu;
>        HWORD offcpu;
>
>        HWORD numhsa;
>        HWORD offhsa;
>
>        BYTE loadparm[8];
>        FWORD xpndinum;
>
>        FWORD xpndsz4K;
>
>        HWORD xpndenum;
>
>        HWORD resv3;
>        HWORD vectssiz;
>        HWORD vectpsum;
>        BYTE ifm[8];
>        BYTE resv4[8];
>        HWORD maxresgp;
>        BYTE resv5[6];
>        HWORD nummpf;
>
>        HWORD offmpf;
>
>        BYTE resv6[4];
>        BYTE cfg[6];
>        FWORD rcci;
>        BYTE cfg11;
>        BYTE numcrl;
>
>        FWORD etrtol;
>        BYTE resv60[3];
>        BYTE maxvm;
>
>
>
>
>        FWORD grzm;
>
>
>        DBLWRD grnmx;
>
>
>        BYTE resv8[16];
>    } SCCB_SCP_INFO;
># 206 "service.h"
>typedef struct _SCCB_CPU_INFO {
>        BYTE cpa;
>        BYTE tod;
>        BYTE cpf[12];
>        BYTE ptyp;
>        BYTE ksid;
>    } SCCB_CPU_INFO;
># 251 "service.h"
>typedef struct _SCCB_HSA_INFO {
>        HWORD hssz;
>        FWORD ahsa;
>    } SCCB_HSA_INFO;
>
>
>typedef struct _SCCB_MPF_INFO {
>        HWORD mpfy;
>    } SCCB_MPF_INFO;
>
>
>typedef struct _SCCB_CHP_INFO {
>        BYTE installed[32];
>        BYTE standby[32];
>        BYTE online[32];
>    } SCCB_CHP_INFO;
>
>
>typedef struct _SCCB_CHSET {
>        BYTE chanset0a[32];
>        BYTE chanset1a[32];
>        BYTE chanset0b[32];
>        BYTE chanset1b[32];
>        BYTE csconfig;
>        BYTE resv[23];
>    } SCCB_CHSET_INFO;
>
>
>typedef struct _SCCB_CSI_INFO {
>        BYTE csif[8];
>
>        BYTE resv[48];
>    } SCCB_CSI_INFO;
>
>
>
>
>
>
>
>typedef struct _SCCB_EVENT_MASK {
>        HWORD reserved;
>        HWORD length;
>        BYTE masks[32];
>
>
>
>
>    } SCCB_EVENT_MASK;
># 310 "service.h"
>typedef struct _SCCB_EVD_HDR {
>        HWORD totlen;
>
>        BYTE type;
># 326 "service.h"
>        BYTE flag;
>
>        HWORD resv;
>    } SCCB_EVD_HDR;
>
>
>
>typedef struct _SCCB_EVD_BK {
>        HWORD msglen;
>        BYTE const1[51];
>        HWORD cplen;
>        BYTE const2[24];
>        HWORD tdlen;
>        BYTE const3[2];
>        BYTE sdtlen;
>        BYTE const4;
>        BYTE tmlen;
>        BYTE const5;
>
>    } SCCB_EVD_BK;
>
>
>typedef struct _SCCB_MCD_BK {
>        HWORD length;
>        HWORD type;
>        FWORD tag;
>        FWORD revcd;
>    } SCCB_MCD_BK;
>
>
>typedef struct _SCCB_OBJ_HDR {
>        HWORD length;
>        HWORD type;
>
>
>
>
>    } SCCB_OBJ_HDR;
>
>
>typedef struct _SCCB_MTO_BK {
>        BYTE ltflag[2];
># 378 "service.h"
>        BYTE presattr[4];
>
>
>
>
>
>
>
>    } SCCB_MTO_BK;
>
>
>typedef struct _SCCB_MGO_BK {
>        FWORD seq;
>        BYTE time[11];
>        BYTE resv1;
>        BYTE date[7];
>        BYTE resv2;
>        BYTE mflag[2];
>
>
>
>        BYTE presattr[4];
>
>
>
>
>
>
>
>        BYTE bckattr[4];
>
>
>
>
>        BYTE sysname[8];
>        BYTE jobname[8];
>    } SCCB_MGO_BK;
>
>
>typedef struct _SCCB_CPI_BK {
>        BYTE id_fmt;
>        BYTE resv0;
>        BYTE system_type[8];
>        DBLWRD resv1;
>        BYTE system_name[8];
>        DBLWRD resv2;
>        DBLWRD system_level;
>        DBLWRD resv3;
>        BYTE sysplex_name[8];
>        BYTE resv4[16];
>    } SCCB_CPI_BK;
>
>
>typedef struct _SCCB_NLS_BK {
>        HWORD scpgid;
>        HWORD scpsgid;
>        HWORD dcpgid;
>        HWORD dcpsgid;
>    } SCCB_NLS_BK;
>
>
>typedef struct _SCCB_SGQ_BK {
>    HWORD count;
>    BYTE unit;
>
>
>
>    } SCCB_SGQ_BK;
>
>
>
>
>typedef struct _SCCB_XST_INFO {
>        HWORD elmid;
>
>        BYTE resv1[6];
>        FWORD elmsin;
>        FWORD elmein;
>        BYTE elmchar;
>
>        BYTE resv2[39];
>    } SCCB_XST_INFO;
>
>typedef struct _SCCB_XST_MAP {
>        FWORD incnum;
>        FWORD resv;
>
>
>    } SCCB_XST_MAP;
>
>
>
>
>
>typedef struct _SCCB_SCEDIO_BK {
>        BYTE flag0;
>        BYTE flag1;
>
>
>        BYTE flag2;
>        BYTE flag3;
>
>
>    } SCCB_SCEDIO_BK;
>
>typedef struct _SCCB_SCEDIOV_BK {
>        BYTE type;
>
>
>
>
>        BYTE flag1;
>        BYTE flag2;
>        BYTE flag3;
>        DBLWRD seek;
>        DBLWRD ncomp;
>        DBLWRD length;
>        DBLWRD resv2;
>        DBLWRD resv3;
>        DBLWRD sto;
>        BYTE filename[256];
>    } SCCB_SCEDIOV_BK;
>
>typedef struct _SCCB_SCEDIOR_BK {
>        BYTE type;
>
>
>        BYTE flag1;
>        BYTE flag2;
>        BYTE flag3;
>        FWORD origin;
>        FWORD resv1;
>        FWORD resv2;
>        BYTE image[8];
>    } SCCB_SCEDIOR_BK;
># 124 "hercules.h" 2
>
># 1 "hsocket.h" 1
># 150 "hsocket.h"
>extern int read_socket(int fd, void *ptr, int nbytes);
>extern int write_socket(int fd, const void *ptr, int nbytes);
># 126 "hercules.h" 2
>
>
>
># 1 "hstructs.h" 1
>
>
>
>
>
>
># 1 "hercules.h" 1
>
>
>
>
>
>
>
># 1 "./config.h" 1
># 9 "hercules.h" 2
># 47 "hercules.h"
># 1 "feature.h" 1
>
>
>
>
># 1 "./config.h" 1
># 6 "feature.h" 2
># 26 "feature.h"
># 1 "featall.h" 1
># 27 "feature.h" 2
>
>
># 1 "feat370.h" 1
># 30 "feature.h" 2
># 38 "feature.h"
># 1 "featchk.h" 1
># 39 "feature.h" 2
># 48 "hercules.h" 2
>
>
>
>
>
># 1 "cpuint.h" 1
># 54 "hercules.h" 2
># 8 "hstructs.h" 2
># 1 "opcode.h" 1
># 10 "opcode.h"
># 1 "hercules.h" 1
>
>
>
>
>
>
>
># 1 "./config.h" 1
># 9 "hercules.h" 2
># 47 "hercules.h"
># 1 "feature.h" 1
>
>
>
>
># 1 "./config.h" 1
># 6 "feature.h" 2
># 26 "feature.h"
># 1 "featall.h" 1
># 27 "feature.h" 2
>
>
># 1 "feat370.h" 1
># 30 "feature.h" 2
># 38 "feature.h"
># 1 "featchk.h" 1
># 39 "feature.h" 2
># 48 "hercules.h" 2
>
>
>
>
>
># 1 "cpuint.h" 1
># 54 "hercules.h" 2
># 11 "opcode.h" 2
># 131 "opcode.h"
>typedef void (__attribute__ (( regparm(2) )) *zz_func) (BYTE inst[], REGS *regs);
>
>
>
>
>
>
>
>extern zz_func s370_opcode_table[];
>extern zz_func s390_opcode_table[];
>extern zz_func z900_opcode_table[];
>
>extern zz_func opcode_table[][3+2];
>extern zz_func opcode_01xx[][3+2];
>extern zz_func v_opcode_a4xx[][3+2];
>extern zz_func opcode_a5xx[][3+2];
>extern zz_func v_opcode_a5xx[][3+2];
>extern zz_func v_opcode_a6xx[][3+2];
>extern zz_func opcode_a7xx[][3+2];
>extern zz_func opcode_b2xx[][3+2];
>extern zz_func opcode_b3xx[][3+2];
>extern zz_func opcode_b9xx[][3+2];
>extern zz_func opcode_c0xx[][3+2];
>extern zz_func opcode_c2xx[][3+2];
>extern zz_func opcode_c4xx[][3+2];
>extern zz_func opcode_c6xx[][3+2];
>extern zz_func opcode_c8xx[][3+2];
>extern zz_func opcode_ccxx[][3+2];
>extern zz_func opcode_e3xx[][3+2];
>extern zz_func opcode_e4xx[256][3+2];
>extern zz_func v_opcode_e4xx[][3+2];
>extern zz_func opcode_e5xx[][3+2];
>extern zz_func opcode_e6xx[][3+2];
>extern zz_func opcode_ebxx[][3+2];
>extern zz_func opcode_ecxx[][3+2];
>extern zz_func opcode_edxx[][3+2];
>
>
>
>
>
>typedef int (*func) ();
>
>extern int disasm_table (BYTE inst[], char mnemonic[], char *p);
># 633 "opcode.h"
># 1 "machdep.h" 1
># 35 "machdep.h"
># 1 "opcode.h" 1
># 2736 "opcode.h"
>int s370_startio (REGS *regs, DEVBLK *dev, ORB *orb);
>void *s370_execute_ccw_chain (DEVBLK *dev);
>void *s390_execute_ccw_chain (DEVBLK *dev);
>void *z900_execute_ccw_chain (DEVBLK *dev);
>int stchan_id (REGS *regs, U16 chan);
>int testch (REGS *regs, U16 chan);
>int testio (REGS *regs, DEVBLK *dev, BYTE ibyte);
>int test_subchan (REGS *regs, DEVBLK *dev, IRB *irb);
>int cancel_subchan (REGS *regs, DEVBLK *dev);
>void clear_subchan (REGS *regs, DEVBLK *dev);
>int halt_subchan (REGS *regs, DEVBLK *dev);
>int haltio (REGS *regs, DEVBLK *dev, BYTE ibyte);
>int resume_subchan (REGS *regs, DEVBLK *dev);
>int s370_present_io_interrupt (REGS *regs, U32 *ioid,
>        U32 *ioparm, U32 *iointid, BYTE *csw);
>int s370_present_zone_io_interrupt (U32 *ioid, U32 *ioparm,
>                                              U32 *iointid, BYTE zone);
>void io_reset (void);
>int chp_reset(REGS *, BYTE chpid);
>void channelset_reset(REGS *regs);
> int device_attention (DEVBLK *dev, BYTE unitstat);
> int s370_device_attention (DEVBLK *dev, BYTE unitstat);
>
>
>
>
>
>
>void s370_store_psw (REGS *regs, BYTE *addr);
>int s370_load_psw (REGS *regs, BYTE *addr);
>void s370_process_trace (REGS *regs);
>
>
>int s390_load_psw (REGS *regs, BYTE *addr);
>void s390_store_psw (REGS *regs, BYTE *addr);
>void s390_process_trace (REGS *regs);
>
>
>int z900_load_psw (REGS *regs, BYTE *addr);
>void z900_store_psw (REGS *regs, BYTE *addr);
>void z900_process_trace (REGS *regs);
>
>
>int cpu_init (int cpu, REGS *regs, REGS *hostregs);
>void s370_perform_io_interrupt (REGS *regs);
>void s370_checkstop_config(void);
>
> void (__attribute__ (( regparm(2) )) s370_program_interrupt) (REGS *regs, int code);
>
>
> void (__attribute__ (( regparm(2) )) s390_program_interrupt) (REGS *regs, int code);
>
> void (__attribute__ (( regparm(2) )) s370_program_interrupt) (REGS *regs, int code);
>void *cpu_thread (int *cpu);
> void copy_psw (REGS *regs, BYTE *addr);
>void display_psw (REGS *regs);
>
>
>
>int s370_diag_devtype (int r1, int r2, REGS *regs);
>int s370_syncblk_io (int r1, int r2, REGS *regs);
>int s370_syncgen_io (int r1, int r2, REGS *regs);
>void s370_extid_call (int r1, int r2, REGS *regs);
>int s370_cpcmd_call (int r1, int r2, REGS *regs);
>void s370_pseudo_timer (U32 code, int r1, int r2, REGS *regs);
>void s370_access_reipl_data (int r1, int r2, REGS *regs);
>int s370_diag_ppagerel (int r1, int r2, REGS *regs);
>void s370_vm_info (int r1, int r2, REGS *regs);
>int s370_device_info (int r1, int r2, REGS *regs);
>
>
>
>int s370_vm_blockio (int r1, int r2, REGS *regs);
>
>
>
>void s370_load_real_address_proc (REGS *regs,
>    int r1, int b2, U32 effective_addr2);
>
>
>
>void packed_to_binary (BYTE *dec, int len, U64 *result,
>    int *ovf, int *dxf);
>void binary_to_packed (S64 bin, BYTE *result);
>
>
>
>void s370_diagnose_call (U32 effective_addr2, int b2, int r1, int r3,
>    REGS *regs);
>
>
>
>void s370_scpend_call (void);
>int s370_mssf_call (int r1, int r2, REGS *regs);
>void s370_diag204_call (int r1, int r2, REGS *regs);
>void s370_diag224_call (int r1, int r2, REGS *regs);
>
>
>
>void s370_perform_external_interrupt (REGS *regs);
>void s370_store_status (REGS *ssreg, U64 aaddr);
>void store_status (REGS *ssreg, U64 aaddr);
>
>
>
>int load_ipl (U16 lcss, U16 devnum, int cpu, int clear);
>int s370_load_ipl (U16 lcss, U16 devnum, int cpu, int clear);
>int system_reset (int cpu, int clear);
>int s370_system_reset (int cpu, int clear);
>int cpu_reset (REGS *regs);
>int s370_cpu_reset (REGS *regs);
>int initial_cpu_reset (REGS *regs);
>int s370_initial_cpu_reset (REGS *regs);
>int s370_common_load_begin (int cpu, int clear);
>int s370_common_load_finish (REGS *regs);
>void storage_clear(void);
>void xstorage_clear(void);
>
>
>
>void set_sce_dir (char *path);
>char *get_sce_dir ();
>int load_main (char *fname, U64 startloc);
>int s370_load_main (char *fname, U64 startloc);
>int load_hmc (char *fname, int cpu, int clear);
>int s370_load_hmc (char *fname, int cpu, int clear);
>void s370_sclp_scedio_request (SCCB_HEADER *);
>void s370_sclp_scedio_event (SCCB_HEADER *);
>
>
>
>int s370_present_mck_interrupt (REGS *regs, U64 *mcic, U32 *xdmg,
>    U64 *fsta);
>U32 channel_report (REGS *);
>void machine_check_crwpend (void);
>void s370_sync_mck_interrupt (REGS *regs);
>void sigabend_handler (int signo);
>
>
>
>extern void copy_opcode_tables ();
>void set_opcode_pointers (REGS *regs);
>
>
>
>void s370_display_inst (REGS *regs, BYTE *inst);
>void display_inst (REGS *regs, BYTE *inst);
>
>
>
>void s370_sie_exit (REGS *regs, int code);
>void s370_diagnose_002 (REGS *regs, int r1, int r3);
>
>
>
>void s370_trap_x (int trap_is_trap4, REGS *regs, U32 trap_operand);
>void s370_form_stack_entry (BYTE etype, U32 retna, U32 calla,
>    U32 csi, U32 pcnum, REGS *regs);
>U32 s370_locate_stack_entry (int prinst, LSED *lsedptr,
>    REGS *regs);
>void s370_stack_modify (U32 lsea, U32 m1, U32 m2, REGS *regs);
>void s370_stack_extract (U32 lsea, int r1, int code, REGS *regs);
>void s370_unstack_registers (int gtype, U32 lsea, int r1,
>    int r2, REGS *regs);
>int s370_program_return_unstack (REGS *regs, U64 *lsedap, int *rc);
>
>
>
>U32 s370_trace_br (int amode, U32 ia, REGS *regs);
>
>U32 s390_trace_br (int amode, U32 ia, REGS *regs);
>
>U32 s370_trace_bsg (U32 alet, U32 ia, REGS *regs);
>U32 s370_trace_ssar (int ssair, U16 sasn, REGS *regs);
>U32 s370_trace_pc (U32 pcea, REGS *regs);
>U32 s370_trace_pr (REGS *newregs, REGS *regs);
>U32 s370_trace_pt (int pti, U16 pasn, U32 gpr2, REGS *regs);
>U32 s370_trace_tr (int r1, int r3, U32 op, REGS *regs);
>U32 s370_trace_tg (int r1, int r3, U32 op, REGS *regs);
>U32 s370_trace_ms (int br_ind, U32 ia, REGS *regs);
>
>
>
>int s370_plo_cl (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_clg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_clgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_clx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_cs (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_dcs (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_dcsg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_dcsgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_dcsx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csst (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csstg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csstgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csstx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csdst (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csdstg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csdstgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csdstx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_cstst (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_cststg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_cststgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_cststx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_execute_01xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_a4xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_a5xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_a6xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_a7xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_b2xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_b3xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_b9xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_c0xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_e3xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_e4xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_e5xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_ebxx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_ecxx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_edxx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_operation_exception) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_dummy_instruction) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_fix_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_svc_assist) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_obtain_local_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_release_local_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_obtain_cms_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_release_cms_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace_svc_interruption) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace_program_interruption) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace_initial_srb_dispatch) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace_io_interruption) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace_task_dispatch) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace_svc_return) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_compression_call) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_cipher_message_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_cipher_message_with_chaining_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compute_intermediate_message_digest_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compute_last_message_digest_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compute_message_authentication_code_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_perform_cryptographic_key_management_operation_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_cipher_message_with_cipher_feedback_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_cipher_message_with_counter_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_cipher_message_with_output_feedback_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_perform_cryptographic_computation_r) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_branch_and_set_authority) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_in_subspace_group) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_and_stack) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_swap_and_purge) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_diagnose) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_primary_asn) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_primary_asn_and_instance) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_secondary_asn) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_secondary_asn_and_instance) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_stacked_registers) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_stacked_state) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_address_space_control) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_psw_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_storage_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_storage_key_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_virtual_storage_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_invalidate_page_table_entry) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_address_space_parameters) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_control) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_program_status_word) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_real_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_using_real_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_lock_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_modify_stacked_state) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_to_primary) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_to_secondary) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_with_destination_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_with_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_with_optional_specifications) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_with_source_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_program_call) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_program_return) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_program_transfer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_program_transfer_with_instance) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_purge_accesslist_lookaside_buffer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_purge_translation_lookaside_buffer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_reset_reference_bit) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_reset_reference_bit_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_address_space_control) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_address_space_control_fast) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_clock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_clock_comparator) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_clock_programmable_field) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_cpu_timer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_prefix) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_psw_key_from_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_secondary_asn) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_secondary_asn_with_instance) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_storage_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_storage_key_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_system_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_signal_processor) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_clock_comparator) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_control) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_cpu_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_cpu_id) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_cpu_timer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_prefix) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_system_information) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_then_and_system_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_then_or_system_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_using_real_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_access) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_block) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_protection) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_add_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_edit_x_edit_and_mark) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_and_round_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_zero_and_add) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_decimal) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_inter_user_communication_vehicle) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_start_interpretive_execution) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_zone_parameter) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_zone_parameter) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_pending_zone_interrupt) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_signal_adapter) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_load_positive_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_halve_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_unnormal_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_unnormal_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_halve_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_unnormal_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_unnormal_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_unnormal_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_unnormal_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_short_to_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_unnormal_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_unnormal_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_float_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_float_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_float_short_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_float_ext_to_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fixed_to_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fixed_to_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fixed_to_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_short_to_fixed_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_long_to_fixed_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_ext_to_fixed_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_short_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_long_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_ext_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_float_short_to_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_float_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_float_short_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_zero_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_zero_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_zero_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_unnormal_float_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_unnormal_float_long_to_ext_low_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_unnormal_float_long_to_ext_high_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_unnormal_float_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_unnormal_float_long_to_ext_low_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_unnormal_float_long_to_ext_high_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_unnormal_float_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_unnormal_float_long_to_ext_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_unnormal_float_long_to_ext_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_unnormal_float_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_unnormal_float_long_to_ext_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_unnormal_float_long_to_ext_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_float_long_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_float_short_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_float_long_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_float_short_y) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_add_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_and_link_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_and_link) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_and_save_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_and_save) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_and_save_and_set_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_and_set_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_condition_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_condition) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_count_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_count) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_index_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_index_low_or_equal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_condition) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_and_save) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_count) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_index_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_index_low_or_equal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_checksum) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_form_codeword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_swap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_double_and_swap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_swap_and_store) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_characters_under_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_character_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_long_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_string) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_until_substring_equal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_utf16_to_utf8) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_utf16_to_utf32) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_utf32_to_utf16) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_utf32_to_utf8) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_utf8_to_utf16) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_utf8_to_utf32) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_to_binary) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_to_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_copy_access) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_access_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_characters_under_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_program_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_access_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_address_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_monitor_call) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_inverse) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_long_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_numerics) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_string) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_with_offset) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_zones) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_or_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_perform_locked_operation) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_pack) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_search_string) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_search_string_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_access_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_program_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_double) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_double_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_single) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_single_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_double) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_double_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_single) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_single_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_access_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_characters_under_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_clock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_clock_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_clock_fast) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_supervisor_call) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_and_set) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_under_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_under_mask_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_under_mask_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_and_test) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_and_test_reverse) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_and_test_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_and_test_reverse_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_unpack) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_update_tree) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_add_immediate_long_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_immediate_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_with_signed_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_with_signed_immediate_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_branch_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_branch_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_branch_relative_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_branch_relative_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_trap_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_trap_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_immediate_halfword_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_immediate_long_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_immediate_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_immediate_and_branch) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_immediate_and_branch_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_immediate_and_branch_relative) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_immediate_and_branch_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_immediate_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_immediate_and_trap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_branch_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_branch_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_branch_relative_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_branch_relative_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_trap_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_trap_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_and_branch) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_and_branch_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_and_branch_relative) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_and_branch_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_and_trap_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_and_trap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_fullword_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_halfword_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_long_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_relative_long_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_relative_long_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_relative_long_long_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_relative_long_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_cache_attribute) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_address_extended_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_halfword_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_halfword_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_halfword_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_halfword_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_relative_long_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_relative_long_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_fullword_from_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_halfword_from_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_long_from_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_immediate_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_immediate_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_prefetch_data) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_prefetch_data_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_then_and_selected_bits_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_then_exclusive_or_selected_bits_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_then_insert_selected_bits_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_then_or_selected_bits_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_halfword_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_relative_long_long) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_add_high_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_high_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_high_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_high_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_high_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_with_signed_immediate_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_with_signed_immediate_high_n) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_count_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_high_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_high_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_byte_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fullword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_halfword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_character_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_halfword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_then_insert_selected_bits_high_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_then_insert_selected_bits_low_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_character_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_fullword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_halfword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_high_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_high_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_high_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_high_high_low_register) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_load_and_add) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_add_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_add_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_add_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_and) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_and_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_exclusive_or) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_exclusive_or_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_or) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_or_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_pair_disjoint) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_pair_disjoint_long) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_load_on_condition_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_on_condition_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_on_condition) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_on_condition_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_on_condition) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_on_condition_long) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_add_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_distinct_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_distinct_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_distinct_signed_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_distinct_long_signed_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_single_distinct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_single_distinct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_single_logical_distinct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_single_logical_distinct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_distinct_long_register) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_population_count) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_load_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fullword_high_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_fullword_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_thirtyone_and_trap) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_trap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_then_insert_selected_bits_long_reg_n) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_branch_prediction_preload) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_prediction_relative_preload) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_next_instruction_access_intent) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_clear_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_halt_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_modify_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_resume_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_address_limit) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_channel_monitor) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_reset_channel_path) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_start_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_cancel_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_channel_path_status) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_channel_report_word) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_pending_interruption) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_start_io) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_io) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_halt_io) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_channel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_channel_id) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_connect_channel_set) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_disconnect_channel_set) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_service_call) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_channel_subsystem_call) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_page_in) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_page_out) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_invalidate_expanded_storage_block_entry) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_v_test_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_complement_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_count_left_zeros_in_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_count_ones_in_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_extract_vct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_extract_vector_modes) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_restore_vr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_save_changed_vr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_save_vr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_load_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_load_vmr_complement) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_store_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_and_to_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_or_to_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_exclusive_or_to_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_save_vsr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_save_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_restore_vsr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_restore_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_load_vct_from_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_clear_vr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_set_vector_mask_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_load_vix_from_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_store_vector_parameters) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_save_vac) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_restore_vac) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_store_fpc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fpc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_fpc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_fpc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_bfp_rounding_mode_2bit) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_bfp_rounding_mode_3bit) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trap2) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trap4) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_resume_program) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_to_binary_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_to_decimal_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_carry_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_borrow_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_carry_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_borrow_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_carry_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_borrow_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_carry) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_borrow) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_single_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_single_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_single_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_single_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_pair_to_quadword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_pair_from_quadword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_stacked_registers_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_psw) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_and_set_extended_authority) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_address_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_perform_frame_management_function) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_perform_timing_facility_function) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_perform_topology_function) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_reset_reference_bits_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_facility_list) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_facility_list_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_control_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_control_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_multiple_disjoint) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_multiple_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_multiple_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_multiple_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_multiple_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_using_real_address_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_using_real_address_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_addressing_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_addressing_mode_24) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_addressing_mode_31) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_addressing_mode_64) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_program_status_word_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_real_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_left_single_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_left_single_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_single_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_single_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_single_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_single_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_thirtyone_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_under_mask_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_under_mask_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_count_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_real_address_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_count_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_count_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_swap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_double_and_swap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_index_high_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_index_low_or_equal_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_index_high_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_index_low_or_equal_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_characters_under_mask_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_characters_under_mask_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_characters_under_mask_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_condition_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_and_save_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_thirtyone) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_immediate_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_immediate_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_immediate_low_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_immediate_low_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate_low_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate_low_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate_low_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate_low_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_immediate_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_immediate_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_immediate_low_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_immediate_low_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_reversed_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_reversed_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_reversed_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_reversed) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_reversed_half) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_reversed_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_reversed) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_reversed_half) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_pack_ascii) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_pack_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_unpack_ascii) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_unpack_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_two_to_two) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_two_to_one) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_one_to_two) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_one_to_one) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_long_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_long_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_swap_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_double_and_swap_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_characters_under_mask_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_to_binary_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_to_decimal_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_character_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_characters_under_mask_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_access_multiple_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_address_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_byte) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_byte_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_multiple_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_real_address_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_access_multiple_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_character_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_characters_under_mask_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_multiple_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_under_mask_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_swap_and_purge_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_invalidate_dat_table_entry) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_replace_dat_table_entry) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_page_table_entry_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_byte_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_byte_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_halfword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_halfword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_character_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_character_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_halfword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_halfword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_find_leftmost_one_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_cpu_time) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_program_parameter) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_basic_freex) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_basic_fretx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_lock_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_unlock_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_decode_next_ccw) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_free_ccwstor) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_locate_vblock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_disp1) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_tpage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_tpage_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_inval_segtab) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_inval_ptable) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_decode_first_ccw) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_dispatch_main) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_locate_rblock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_comm_ccwproc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_unxlate_ccw) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_disp2) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_store_level) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_loc_chgshrpg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_extended_freex) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_extended_fretx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_prefmach_assist) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_long_to_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_short_to_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_long_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_long_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_signal_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_signal_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_signal_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_signal_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_signal_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix32_to_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix32_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix32_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u32_to_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u32_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u32_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u64_to_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u64_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u64_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_ext_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_long_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_short_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_ext_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_long_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_short_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_ext_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_long_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_short_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_ext_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_long_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_short_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_integer_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_integer_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_bfp_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_bfp_short_to_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_bfp_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_bfp_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_bfp_short_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_bfp_short_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_bfp_long_to_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_bfp_ext_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_bfp_ext_to_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_short_to_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_class_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_class_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_class_bfp_ext) (BYTE inst[], REGS *regs);
>
>
>void (__attribute__ (( regparm(2) )) s370_copy_sign_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fpr_from_gr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_gr_from_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_dfp_rounding_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fpc_and_signal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_fpc_and_signal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_signal_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_signal_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_exponent_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_exponent_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix32_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix32_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u32_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u32_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u64_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_sbcd128_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_sbcd64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_ubcd128_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_ubcd64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_zoned_to_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_zoned_to_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_ext_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_long_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_ext_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_long_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_ext_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_long_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_ext_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_long_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_ext_to_sbcd128_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_long_to_sbcd64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_ext_to_ubcd128_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_long_to_ubcd64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_ext_to_zoned) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_long_to_zoned) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_biased_exponent_dfp_ext_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_biased_exponent_dfp_long_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_significance_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_significance_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_biased_exponent_fix64_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_biased_exponent_fix64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_dfp_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_dfp_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_dfp_ext_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_dfp_long_to_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_quantize_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_quantize_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_reround_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_reround_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_coefficient_left_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_coefficient_left_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_coefficient_right_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_coefficient_right_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_class_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_class_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_class_dfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_group_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_group_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_group_dfp_short) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_perform_floating_point_operation) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_perform_processor_assist) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_transaction_nesting_depth) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_nontransactional_store_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_transaction_abort) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_transaction_begin) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_transaction_begin_constrained) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_transaction_end) (BYTE inst[], REGS *regs);
># 36 "machdep.h" 2
># 294 "machdep.h"
>static __inline__ BYTE cmpxchg1_i686(BYTE *old, BYTE new, void *ptr) {
> BYTE code;
> __asm__ __volatile__ (
>         "lock\n\t"
>         "cmpxchgb %b3,%4\n\t"
>         "setnz   %b0"
>         : "=q"(code), "=a"(*old)
>         : "1" (*old),
>           "q" (new),
>           "m" (*(BYTE *)ptr)
>         : "cc" );
> return code;
>}
>
>
>static __inline__ BYTE cmpxchg4_i686(U32 *old, U32 new, void *ptr) {
> BYTE code;
> __asm__ __volatile__ (
>         "lock\n\t"
>         "cmpxchgl %3,%4\n\t"
>         "setnz   %b0"
>         : "=q"(code), "=a"(*old)
>         : "1" (*old),
>           "q" (new),
>           "m" (*(U32 *)ptr)
>         : "cc" );
> return code;
>}
>
>
>static __inline__ BYTE cmpxchg8_i686(U64 *old, U64 new, void *ptr) {
> BYTE code;
>__asm__ __volatile__ (
>         "xchgl   %%ebx,%%esi\n\t"
>         "lock\n\t"
>         "cmpxchg8b %5\n\t"
>         "xchgl   %%ebx,%%esi\n\t"
>         "setnz   %b0"
>         : "=q"(code), "=A"(*old)
>         : "1" (*old),
>           "S" ((unsigned long)new),
>           "c" ((unsigned long)(new >> 32)),
>           "m" (*(U64 *)ptr)
>         : "cc");
> return code;
>}
>
>
>static __inline__ U64 fetch_dw_i686_noswap(void *ptr)
>{
> U64 value = *(U64 *)ptr;
>__asm__ __volatile__ (
>         "xchgl   %%ebx,%%esi\n\t"
>         "lock\n\t"
>         "cmpxchg8b (%4)\n\t"
>         "xchgl   %%ebx,%%esi\n\t"
>         : "=A" (value)
>         : "0" (value),
>           "S" ((unsigned long)value),
>           "c" ((unsigned long)(value >> 32)),
>           "D" (ptr));
> return value;
>}
>
>
>static __inline__ void store_dw_i686_noswap(void *ptr, U64 value) {
>__asm__ __volatile__ (
>         "xchgl   %%ebx,%%esi\n\t"
>         "1:\t"
>         "lock\n\t"
>         "cmpxchg8b %3\n\t"
>         "jne     1b\n\t"
>         "xchgl   %%ebx,%%esi\n\t"
>         :
>         : "A" (*(U64 *)ptr),
>           "S" ((unsigned long)value),
>           "c" ((unsigned long)(value >> 32)),
>           "m" (*(U64 *)ptr));
>}
># 592 "machdep.h"
>      static __inline__ U16 fetch_hw_noswap(void *ptr) {
>        return *(U16 *)ptr;
>      }
># 616 "machdep.h"
>      static __inline__ void store_hw_noswap(void *ptr, U16 value) {
>        *(U16 *)ptr = value;
>      }
># 638 "machdep.h"
>      static __inline__ U32 fetch_fw_noswap(const void *ptr) {
>        return *(U32 *)ptr;
>      }
># 662 "machdep.h"
>      static __inline__ void store_fw_noswap(void *ptr, U32 value) {
>        *(U32 *)ptr = value;
>      }
># 786 "machdep.h"
>static __inline__ int cmpxchg16(U64 *old1, U64 *old2, U64 new1, U64 new2, volatile void *ptr) {
> int code;
> if (*old1 == *(U64 *)ptr && *old2 == *((U64 *)ptr + 1))
> {
>     *(U64 *)ptr = new1;
>     *((U64 *)ptr + 1) = new2;
>     code = 0;
> }
> else
> {
>     *old1 = *((U64 *)ptr);
>     *old2 = *((U64 *)ptr + 1);
>     code = 1;
> }
> return code;
>}
># 634 "opcode.h" 2
># 2736 "opcode.h"
>int s370_startio (REGS *regs, DEVBLK *dev, ORB *orb);
>void *s370_execute_ccw_chain (DEVBLK *dev);
>void *s390_execute_ccw_chain (DEVBLK *dev);
>void *z900_execute_ccw_chain (DEVBLK *dev);
>int stchan_id (REGS *regs, U16 chan);
>int testch (REGS *regs, U16 chan);
>int testio (REGS *regs, DEVBLK *dev, BYTE ibyte);
>int test_subchan (REGS *regs, DEVBLK *dev, IRB *irb);
>int cancel_subchan (REGS *regs, DEVBLK *dev);
>void clear_subchan (REGS *regs, DEVBLK *dev);
>int halt_subchan (REGS *regs, DEVBLK *dev);
>int haltio (REGS *regs, DEVBLK *dev, BYTE ibyte);
>int resume_subchan (REGS *regs, DEVBLK *dev);
>int s370_present_io_interrupt (REGS *regs, U32 *ioid,
>        U32 *ioparm, U32 *iointid, BYTE *csw);
>int s370_present_zone_io_interrupt (U32 *ioid, U32 *ioparm,
>                                              U32 *iointid, BYTE zone);
>void io_reset (void);
>int chp_reset(REGS *, BYTE chpid);
>void channelset_reset(REGS *regs);
> int device_attention (DEVBLK *dev, BYTE unitstat);
> int s370_device_attention (DEVBLK *dev, BYTE unitstat);
>
>
>
>
>
>
>void s370_store_psw (REGS *regs, BYTE *addr);
>int s370_load_psw (REGS *regs, BYTE *addr);
>void s370_process_trace (REGS *regs);
>
>
>int s390_load_psw (REGS *regs, BYTE *addr);
>void s390_store_psw (REGS *regs, BYTE *addr);
>void s390_process_trace (REGS *regs);
>
>
>int z900_load_psw (REGS *regs, BYTE *addr);
>void z900_store_psw (REGS *regs, BYTE *addr);
>void z900_process_trace (REGS *regs);
>
>
>int cpu_init (int cpu, REGS *regs, REGS *hostregs);
>void s370_perform_io_interrupt (REGS *regs);
>void s370_checkstop_config(void);
>
> void (__attribute__ (( regparm(2) )) s370_program_interrupt) (REGS *regs, int code);
>
>
> void (__attribute__ (( regparm(2) )) s390_program_interrupt) (REGS *regs, int code);
>
> void (__attribute__ (( regparm(2) )) s370_program_interrupt) (REGS *regs, int code);
>void *cpu_thread (int *cpu);
> void copy_psw (REGS *regs, BYTE *addr);
>void display_psw (REGS *regs);
>
>
>
>int s370_diag_devtype (int r1, int r2, REGS *regs);
>int s370_syncblk_io (int r1, int r2, REGS *regs);
>int s370_syncgen_io (int r1, int r2, REGS *regs);
>void s370_extid_call (int r1, int r2, REGS *regs);
>int s370_cpcmd_call (int r1, int r2, REGS *regs);
>void s370_pseudo_timer (U32 code, int r1, int r2, REGS *regs);
>void s370_access_reipl_data (int r1, int r2, REGS *regs);
>int s370_diag_ppagerel (int r1, int r2, REGS *regs);
>void s370_vm_info (int r1, int r2, REGS *regs);
>int s370_device_info (int r1, int r2, REGS *regs);
>
>
>
>int s370_vm_blockio (int r1, int r2, REGS *regs);
>
>
>
>void s370_load_real_address_proc (REGS *regs,
>    int r1, int b2, U32 effective_addr2);
>
>
>
>void packed_to_binary (BYTE *dec, int len, U64 *result,
>    int *ovf, int *dxf);
>void binary_to_packed (S64 bin, BYTE *result);
>
>
>
>void s370_diagnose_call (U32 effective_addr2, int b2, int r1, int r3,
>    REGS *regs);
>
>
>
>void s370_scpend_call (void);
>int s370_mssf_call (int r1, int r2, REGS *regs);
>void s370_diag204_call (int r1, int r2, REGS *regs);
>void s370_diag224_call (int r1, int r2, REGS *regs);
>
>
>
>void s370_perform_external_interrupt (REGS *regs);
>void s370_store_status (REGS *ssreg, U64 aaddr);
>void store_status (REGS *ssreg, U64 aaddr);
>
>
>
>int load_ipl (U16 lcss, U16 devnum, int cpu, int clear);
>int s370_load_ipl (U16 lcss, U16 devnum, int cpu, int clear);
>int system_reset (int cpu, int clear);
>int s370_system_reset (int cpu, int clear);
>int cpu_reset (REGS *regs);
>int s370_cpu_reset (REGS *regs);
>int initial_cpu_reset (REGS *regs);
>int s370_initial_cpu_reset (REGS *regs);
>int s370_common_load_begin (int cpu, int clear);
>int s370_common_load_finish (REGS *regs);
>void storage_clear(void);
>void xstorage_clear(void);
>
>
>
>void set_sce_dir (char *path);
>char *get_sce_dir ();
>int load_main (char *fname, U64 startloc);
>int s370_load_main (char *fname, U64 startloc);
>int load_hmc (char *fname, int cpu, int clear);
>int s370_load_hmc (char *fname, int cpu, int clear);
>void s370_sclp_scedio_request (SCCB_HEADER *);
>void s370_sclp_scedio_event (SCCB_HEADER *);
>
>
>
>int s370_present_mck_interrupt (REGS *regs, U64 *mcic, U32 *xdmg,
>    U64 *fsta);
>U32 channel_report (REGS *);
>void machine_check_crwpend (void);
>void s370_sync_mck_interrupt (REGS *regs);
>void sigabend_handler (int signo);
>
>
>
>extern void copy_opcode_tables ();
>void set_opcode_pointers (REGS *regs);
>
>
>
>void s370_display_inst (REGS *regs, BYTE *inst);
>void display_inst (REGS *regs, BYTE *inst);
>
>
>
>void s370_sie_exit (REGS *regs, int code);
>void s370_diagnose_002 (REGS *regs, int r1, int r3);
>
>
>
>void s370_trap_x (int trap_is_trap4, REGS *regs, U32 trap_operand);
>void s370_form_stack_entry (BYTE etype, U32 retna, U32 calla,
>    U32 csi, U32 pcnum, REGS *regs);
>U32 s370_locate_stack_entry (int prinst, LSED *lsedptr,
>    REGS *regs);
>void s370_stack_modify (U32 lsea, U32 m1, U32 m2, REGS *regs);
>void s370_stack_extract (U32 lsea, int r1, int code, REGS *regs);
>void s370_unstack_registers (int gtype, U32 lsea, int r1,
>    int r2, REGS *regs);
>int s370_program_return_unstack (REGS *regs, U64 *lsedap, int *rc);
>
>
>
>U32 s370_trace_br (int amode, U32 ia, REGS *regs);
>
>U32 s390_trace_br (int amode, U32 ia, REGS *regs);
>
>U32 s370_trace_bsg (U32 alet, U32 ia, REGS *regs);
>U32 s370_trace_ssar (int ssair, U16 sasn, REGS *regs);
>U32 s370_trace_pc (U32 pcea, REGS *regs);
>U32 s370_trace_pr (REGS *newregs, REGS *regs);
>U32 s370_trace_pt (int pti, U16 pasn, U32 gpr2, REGS *regs);
>U32 s370_trace_tr (int r1, int r3, U32 op, REGS *regs);
>U32 s370_trace_tg (int r1, int r3, U32 op, REGS *regs);
>U32 s370_trace_ms (int br_ind, U32 ia, REGS *regs);
>
>
>
>int s370_plo_cl (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_clg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_clgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_clx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_cs (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_dcs (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_dcsg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_dcsgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_dcsx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csst (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csstg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csstgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csstx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csdst (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csdstg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csdstgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csdstx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_cstst (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_cststg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_cststgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_cststx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_execute_01xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_a4xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_a5xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_a6xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_a7xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_b2xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_b3xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_b9xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_c0xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_e3xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_e4xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_e5xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_ebxx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_ecxx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_edxx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_operation_exception) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_dummy_instruction) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_fix_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_svc_assist) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_obtain_local_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_release_local_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_obtain_cms_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_release_cms_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace_svc_interruption) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace_program_interruption) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace_initial_srb_dispatch) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace_io_interruption) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace_task_dispatch) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace_svc_return) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_compression_call) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_cipher_message_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_cipher_message_with_chaining_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compute_intermediate_message_digest_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compute_last_message_digest_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compute_message_authentication_code_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_perform_cryptographic_key_management_operation_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_cipher_message_with_cipher_feedback_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_cipher_message_with_counter_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_cipher_message_with_output_feedback_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_perform_cryptographic_computation_r) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_branch_and_set_authority) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_in_subspace_group) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_and_stack) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_swap_and_purge) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_diagnose) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_primary_asn) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_primary_asn_and_instance) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_secondary_asn) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_secondary_asn_and_instance) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_stacked_registers) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_stacked_state) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_address_space_control) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_psw_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_storage_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_storage_key_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_virtual_storage_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_invalidate_page_table_entry) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_address_space_parameters) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_control) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_program_status_word) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_real_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_using_real_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_lock_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_modify_stacked_state) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_to_primary) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_to_secondary) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_with_destination_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_with_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_with_optional_specifications) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_with_source_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_program_call) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_program_return) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_program_transfer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_program_transfer_with_instance) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_purge_accesslist_lookaside_buffer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_purge_translation_lookaside_buffer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_reset_reference_bit) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_reset_reference_bit_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_address_space_control) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_address_space_control_fast) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_clock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_clock_comparator) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_clock_programmable_field) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_cpu_timer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_prefix) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_psw_key_from_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_secondary_asn) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_secondary_asn_with_instance) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_storage_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_storage_key_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_system_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_signal_processor) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_clock_comparator) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_control) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_cpu_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_cpu_id) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_cpu_timer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_prefix) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_system_information) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_then_and_system_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_then_or_system_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_using_real_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_access) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_block) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_protection) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_add_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_edit_x_edit_and_mark) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_and_round_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_zero_and_add) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_decimal) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_inter_user_communication_vehicle) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_start_interpretive_execution) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_zone_parameter) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_zone_parameter) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_pending_zone_interrupt) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_signal_adapter) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_load_positive_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_halve_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_unnormal_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_unnormal_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_halve_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_unnormal_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_unnormal_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_unnormal_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_unnormal_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_short_to_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_unnormal_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_unnormal_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_float_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_float_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_float_short_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_float_ext_to_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fixed_to_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fixed_to_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fixed_to_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_short_to_fixed_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_long_to_fixed_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_ext_to_fixed_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_short_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_long_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_ext_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_float_short_to_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_float_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_float_short_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_zero_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_zero_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_zero_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_unnormal_float_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_unnormal_float_long_to_ext_low_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_unnormal_float_long_to_ext_high_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_unnormal_float_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_unnormal_float_long_to_ext_low_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_unnormal_float_long_to_ext_high_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_unnormal_float_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_unnormal_float_long_to_ext_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_unnormal_float_long_to_ext_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_unnormal_float_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_unnormal_float_long_to_ext_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_unnormal_float_long_to_ext_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_float_long_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_float_short_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_float_long_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_float_short_y) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_add_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_and_link_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_and_link) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_and_save_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_and_save) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_and_save_and_set_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_and_set_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_condition_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_condition) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_count_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_count) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_index_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_index_low_or_equal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_condition) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_and_save) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_count) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_index_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_index_low_or_equal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_checksum) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_form_codeword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_swap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_double_and_swap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_swap_and_store) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_characters_under_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_character_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_long_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_string) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_until_substring_equal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_utf16_to_utf8) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_utf16_to_utf32) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_utf32_to_utf16) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_utf32_to_utf8) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_utf8_to_utf16) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_utf8_to_utf32) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_to_binary) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_to_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_copy_access) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_access_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_characters_under_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_program_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_access_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_address_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_monitor_call) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_inverse) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_long_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_numerics) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_string) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_with_offset) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_zones) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_or_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_perform_locked_operation) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_pack) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_search_string) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_search_string_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_access_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_program_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_double) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_double_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_single) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_single_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_double) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_double_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_single) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_single_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_access_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_characters_under_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_clock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_clock_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_clock_fast) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_supervisor_call) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_and_set) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_under_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_under_mask_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_under_mask_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_and_test) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_and_test_reverse) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_and_test_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_and_test_reverse_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_unpack) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_update_tree) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_add_immediate_long_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_immediate_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_with_signed_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_with_signed_immediate_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_branch_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_branch_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_branch_relative_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_branch_relative_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_trap_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_trap_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_immediate_halfword_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_immediate_long_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_immediate_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_immediate_and_branch) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_immediate_and_branch_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_immediate_and_branch_relative) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_immediate_and_branch_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_immediate_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_immediate_and_trap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_branch_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_branch_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_branch_relative_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_branch_relative_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_trap_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_trap_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_and_branch) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_and_branch_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_and_branch_relative) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_and_branch_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_and_trap_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_and_trap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_fullword_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_halfword_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_long_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_relative_long_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_relative_long_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_relative_long_long_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_relative_long_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_cache_attribute) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_address_extended_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_halfword_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_halfword_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_halfword_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_halfword_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_relative_long_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_relative_long_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_fullword_from_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_halfword_from_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_long_from_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_immediate_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_immediate_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_prefetch_data) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_prefetch_data_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_then_and_selected_bits_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_then_exclusive_or_selected_bits_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_then_insert_selected_bits_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_then_or_selected_bits_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_halfword_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_relative_long_long) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_add_high_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_high_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_high_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_high_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_high_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_with_signed_immediate_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_with_signed_immediate_high_n) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_count_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_high_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_high_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_byte_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fullword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_halfword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_character_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_halfword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_then_insert_selected_bits_high_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_then_insert_selected_bits_low_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_character_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_fullword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_halfword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_high_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_high_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_high_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_high_high_low_register) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_load_and_add) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_add_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_add_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_add_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_and) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_and_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_exclusive_or) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_exclusive_or_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_or) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_or_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_pair_disjoint) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_pair_disjoint_long) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_load_on_condition_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_on_condition_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_on_condition) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_on_condition_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_on_condition) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_on_condition_long) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_add_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_distinct_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_distinct_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_distinct_signed_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_distinct_long_signed_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_single_distinct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_single_distinct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_single_logical_distinct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_single_logical_distinct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_distinct_long_register) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_population_count) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_load_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fullword_high_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_fullword_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_thirtyone_and_trap) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_trap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_then_insert_selected_bits_long_reg_n) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_branch_prediction_preload) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_prediction_relative_preload) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_next_instruction_access_intent) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_clear_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_halt_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_modify_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_resume_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_address_limit) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_channel_monitor) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_reset_channel_path) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_start_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_cancel_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_channel_path_status) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_channel_report_word) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_pending_interruption) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_start_io) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_io) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_halt_io) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_channel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_channel_id) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_connect_channel_set) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_disconnect_channel_set) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_service_call) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_channel_subsystem_call) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_page_in) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_page_out) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_invalidate_expanded_storage_block_entry) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_v_test_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_complement_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_count_left_zeros_in_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_count_ones_in_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_extract_vct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_extract_vector_modes) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_restore_vr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_save_changed_vr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_save_vr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_load_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_load_vmr_complement) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_store_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_and_to_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_or_to_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_exclusive_or_to_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_save_vsr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_save_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_restore_vsr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_restore_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_load_vct_from_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_clear_vr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_set_vector_mask_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_load_vix_from_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_store_vector_parameters) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_save_vac) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_restore_vac) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_store_fpc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fpc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_fpc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_fpc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_bfp_rounding_mode_2bit) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_bfp_rounding_mode_3bit) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trap2) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trap4) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_resume_program) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_to_binary_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_to_decimal_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_carry_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_borrow_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_carry_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_borrow_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_carry_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_borrow_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_carry) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_borrow) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_single_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_single_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_single_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_single_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_pair_to_quadword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_pair_from_quadword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_stacked_registers_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_psw) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_and_set_extended_authority) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_address_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_perform_frame_management_function) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_perform_timing_facility_function) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_perform_topology_function) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_reset_reference_bits_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_facility_list) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_facility_list_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_control_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_control_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_multiple_disjoint) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_multiple_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_multiple_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_multiple_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_multiple_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_using_real_address_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_using_real_address_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_addressing_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_addressing_mode_24) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_addressing_mode_31) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_addressing_mode_64) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_program_status_word_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_real_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_left_single_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_left_single_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_single_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_single_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_single_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_single_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_thirtyone_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_under_mask_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_under_mask_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_count_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_real_address_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_count_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_count_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_swap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_double_and_swap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_index_high_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_index_low_or_equal_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_index_high_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_index_low_or_equal_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_characters_under_mask_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_characters_under_mask_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_characters_under_mask_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_condition_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_and_save_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_thirtyone) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_immediate_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_immediate_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_immediate_low_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_immediate_low_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate_low_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate_low_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate_low_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate_low_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_immediate_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_immediate_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_immediate_low_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_immediate_low_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_reversed_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_reversed_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_reversed_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_reversed) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_reversed_half) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_reversed_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_reversed) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_reversed_half) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_pack_ascii) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_pack_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_unpack_ascii) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_unpack_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_two_to_two) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_two_to_one) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_one_to_two) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_one_to_one) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_long_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_long_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_swap_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_double_and_swap_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_characters_under_mask_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_to_binary_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_to_decimal_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_character_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_characters_under_mask_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_access_multiple_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_address_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_byte) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_byte_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_multiple_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_real_address_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_access_multiple_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_character_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_characters_under_mask_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_multiple_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_under_mask_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_swap_and_purge_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_invalidate_dat_table_entry) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_replace_dat_table_entry) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_page_table_entry_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_byte_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_byte_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_halfword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_halfword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_character_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_character_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_halfword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_halfword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_find_leftmost_one_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_cpu_time) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_program_parameter) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_basic_freex) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_basic_fretx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_lock_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_unlock_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_decode_next_ccw) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_free_ccwstor) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_locate_vblock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_disp1) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_tpage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_tpage_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_inval_segtab) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_inval_ptable) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_decode_first_ccw) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_dispatch_main) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_locate_rblock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_comm_ccwproc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_unxlate_ccw) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_disp2) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_store_level) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_loc_chgshrpg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_extended_freex) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_extended_fretx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_prefmach_assist) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_long_to_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_short_to_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_long_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_long_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_signal_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_signal_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_signal_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_signal_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_signal_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix32_to_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix32_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix32_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u32_to_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u32_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u32_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u64_to_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u64_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u64_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_ext_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_long_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_short_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_ext_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_long_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_short_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_ext_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_long_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_short_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_ext_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_long_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_short_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_integer_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_integer_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_bfp_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_bfp_short_to_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_bfp_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_bfp_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_bfp_short_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_bfp_short_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_bfp_long_to_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_bfp_ext_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_bfp_ext_to_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_short_to_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_class_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_class_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_class_bfp_ext) (BYTE inst[], REGS *regs);
>
>
>void (__attribute__ (( regparm(2) )) s370_copy_sign_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fpr_from_gr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_gr_from_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_dfp_rounding_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fpc_and_signal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_fpc_and_signal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_signal_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_signal_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_exponent_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_exponent_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix32_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix32_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u32_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u32_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u64_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_sbcd128_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_sbcd64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_ubcd128_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_ubcd64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_zoned_to_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_zoned_to_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_ext_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_long_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_ext_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_long_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_ext_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_long_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_ext_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_long_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_ext_to_sbcd128_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_long_to_sbcd64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_ext_to_ubcd128_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_long_to_ubcd64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_ext_to_zoned) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_long_to_zoned) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_biased_exponent_dfp_ext_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_biased_exponent_dfp_long_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_significance_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_significance_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_biased_exponent_fix64_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_biased_exponent_fix64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_dfp_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_dfp_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_dfp_ext_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_dfp_long_to_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_quantize_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_quantize_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_reround_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_reround_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_coefficient_left_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_coefficient_left_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_coefficient_right_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_coefficient_right_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_class_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_class_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_class_dfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_group_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_group_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_group_dfp_short) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_perform_floating_point_operation) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_perform_processor_assist) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_transaction_nesting_depth) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_nontransactional_store_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_transaction_abort) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_transaction_begin) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_transaction_begin_constrained) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_transaction_end) (BYTE inst[], REGS *regs);
># 9 "hstructs.h" 2
># 18 "hstructs.h"
>    typedef U32 CPU_BITMAP;
># 40 "hstructs.h"
>struct REGS {
>
>
>
>        int arch_mode;
>
>        DW px;
>        PSW psw;
>        BYTE *ip;
>
>
>        BYTE *aip;
>        uintptr_t aim;
>        BYTE *aie;
>        DW aiv;
>
>        U64 bear;
>        BYTE *bear_ip;
>
>        DW gr[16];
>
>        DW cr[16+16+1];
>
>
>
>        U32 ar[16];
>        U32 fpr[32];
>        U32 fpc;
>
>        U32 dxc;
>        DW mc;
>        DW ea;
>        DW et;
>
>        unsigned int
>                execflag:1,
>                exrl:1,
>                permode:1,
>                instinvalid:1,
>                opinterv:1,
>                checkstop:1,
>                hostint:1,
>                host:1,
>                guest:1;
>        unsigned int
>                dummy:1,
>                configured:1,
>                loadstate:1,
>                ghostregs:1,
>                invalidate:1,
>                tracing:1,
>                stepwait:1,
>                sigpreset:1,
>                sigpireset:1;
>
>        S64 cpu_timer;
>        S64 int_timer;
>        S32 old_timer;
>        U64 clkc;
>
>        S64 tod_epoch;
>        S64 ecps_vtimer;
>        S32 ecps_oldtmr;
>        BYTE *ecps_vtmrpt;
>        U32 instcount;
>        U64 prevcount;
>        U32 mipsrate;
>        U32 siocount;
>        U32 siosrate;
>        U64 siototal;
>        int cpupct;
>        U64 waittod;
>        U64 waittime;
>        DAT dat;
># 148 "hstructs.h"
>        U16 chanset;
>        U32 todpr;
>        U16 monclass;
>        U16 cpuad;
>        BYTE excarid;
>        BYTE opndrid;
>        BYTE exinst[8];
>        BYTE *mainstor;
>        BYTE *storkeys;
>        U64 mainlim;
>
>        PSA_3XX *psa;
># 180 "hstructs.h"
>        REGS *hostregs;
>
>        REGS *guestregs;
>
>        SYSBLK *sysblk;
>
>
>        U64 sie_state;
>
>
>        SIE1BK *siebk;
>        U64 sie_px;
>        U64 sie_mso;
>        U64 sie_xso;
>        U64 sie_xsl;
>        U64 sie_rcpo;
>        U64 sie_scao;
>        S64 sie_epoch;
>
>        unsigned int
>                sie_active:1,
>                sie_mode:1,
>                sie_pref:1;
>
>
>        U16 perc;
>        U64 peradr;
>        BYTE peraid;
>
>
>        CPU_BITMAP cpubit;
>        U32 ints_state;
>        U32 ints_mask;
>
>
>
>
>
>
>        int intwait;
>        int syncio;
>
>        BYTE cpustate;
>        BYTE malfcpu
>                    [8];
>        BYTE emercpu
>                    [8];
>        U16 extccpu;
>        BYTE inst[8];
>
>
>        BYTE *invalidate_main;
>        PSW captured_zpsw;
>
>
>
>
>        jmp_buf progjmp;
>
>        jmp_buf archjmp;
>
>        jmp_buf exitjmp;
>
>        COND intcond;
>        LOCK *cpulock;
>
>
>
>        BYTE aea_mode;
>
>        int aea_ar[16+5];
>
>
>        BYTE aea_common[16+16+1];
>
>
>
>        BYTE aea_aleprot[16];
>
>
>        pi_func program_interrupt;
>        func trace_br;
>
>
>        U64 regs_copy_end;
>
>
>
>
>        FUNC s370_opcode_table[256];
>        FUNC *s370_opcode_a4xx,
>               *s370_opcode_a5xx,
>               *s370_opcode_a6xx,
>
>                s370_opcode_a7xx[256],
>                s370_opcode_b2xx[256],
>                s370_opcode_b9xx[256],
>                s370_opcode_c0xx[256],
>                s370_opcode_e3xx[256],
>                s370_opcode_ebxx[256],
># 288 "hstructs.h"
>               *s370_opcode_b3xx,
>               *s370_opcode_c2xx,
>               *s370_opcode_c4xx,
>               *s370_opcode_c6xx,
>               *s370_opcode_e4xx,
>               *s370_opcode_e5xx,
>               *s370_opcode_e6xx,
>               *s370_opcode_ecxx,
>               *s370_opcode_edxx;
>
>        FUNC s390_opcode_table[256];
>        FUNC *s390_opcode_01xx,
>               *s390_opcode_a4xx,
>               *s390_opcode_a5xx,
>               *s390_opcode_a6xx,
>
>                s390_opcode_a7xx[256],
>                s390_opcode_b2xx[256],
>                s390_opcode_b9xx[256],
>                s390_opcode_c0xx[256],
>                s390_opcode_e3xx[256],
>                s390_opcode_ebxx[256],
># 318 "hstructs.h"
>               *s390_opcode_b3xx,
>               *s390_opcode_c2xx,
>               *s390_opcode_c4xx,
>               *s390_opcode_c6xx,
>               *s390_opcode_e4xx,
>               *s390_opcode_e5xx,
>               *s390_opcode_ecxx,
>               *s390_opcode_edxx;
>
>        FUNC z900_opcode_table[256];
>        FUNC *z900_opcode_01xx,
>               *z900_opcode_a5xx,
>
>                z900_opcode_a7xx[256],
>                z900_opcode_b2xx[256],
>                z900_opcode_b9xx[256],
>                z900_opcode_c0xx[256],
>                z900_opcode_e3xx[256],
>                z900_opcode_ebxx[256],
># 345 "hstructs.h"
>               *z900_opcode_b3xx,
>               *z900_opcode_c2xx,
>               *z900_opcode_c4xx,
>               *z900_opcode_c6xx,
>               *z900_opcode_c8xx,
>               *z900_opcode_ccxx,
>               *z900_opcode_e5xx,
>               *z900_opcode_ecxx,
>               *z900_opcode_edxx;
>
>
>
>        unsigned int tlbID;
>        TLB tlb;
>
>};
># 380 "hstructs.h"
>struct ZPBLK {
>        U64 mso;
>        U64 msl;
>        U64 eso;
>        U64 esl;
>        U64 mbo;
>        BYTE mbk;
>        int mbm;
>        int mbd;
>};
>
>
>
>
>
>struct SYSBLK {
>
>
>        time_t impltime;
>        int arch_mode;
>
>
>
>        int arch_z900;
>        U64 mainsize;
>        BYTE *mainstor;
>        BYTE *storkeys;
>        U32 xpndsize;
>        BYTE *xpndstor;
>        U64 todstart;
>        U64 cpuid;
>        TID impltid;
>        TID wdtid;
>        U16 lparnuml;
>        U16 lparnum;
>        U16 ipldev;
>        int iplcpu;
>        int ipllcss;
>        int numcpu;
>        int numvec;
>        int maxcpu;
>        int cpus;
>        int hicpu;
>        int sysepoch;
>        int topology;
>
>
>        int topchnge;
>
>        COND cpucond;
>        LOCK cpulock[8];
>        TID cputid[8];
>        BYTE ptyp[8];
>        LOCK todlock;
>        TID todtid;
>        REGS *regs[8 +1];
>
>
>        LOCK wklock;
>        BYTE wkaes_reg[32];
>        BYTE wkdea_reg[24];
>        BYTE wkvpaes_reg[32];
>        BYTE wkvpdea_reg[24];
>
>
>
>
>
>        U64 program_parameter;
>
>
>
>
>
>        ZPBLK zpb[8];
># 463 "hstructs.h"
>        U16 mainowner;
>        U16 intowner;
>
>        LOCK mainlock;
>        LOCK intlock;
>        LOCK iointqlk;
>        LOCK sigplock;
>        ATTR detattr;
>        ATTR joinattr;
>
>
>        TID cnsltid;
>        TID socktid;
>
>        int kaidle;
>        int kaintv;
>        int kacnt;
>
>        LOCK cnslpipe_lock;
>        int cnslpipe_flag;
>        int cnslwpipe;
>        int cnslrpipe;
>        LOCK sockpipe_lock;
>        int sockpipe_flag;
>        int sockwpipe;
>        int sockrpipe;
>
>        U64 mbo;
>        BYTE mbk;
>        int mbm;
>        int mbd;
>        int diag8cmd;
>
>
>        BYTE shcmdopt;
>
>
>        int panrate;
>        int timerint;
>        char *pantitle;
>
>        TID haotid;
>
>
>
>        LOCK stape_lock;
>        int auto_scsi_mount_secs;
>
>
>        TID stape_getstat_tid;
>        TID stape_mountmon_tid;
>        COND stape_getstat_cond;
>        u_int stape_getstat_busy:1;
>        LIST_ENTRY stape_status_link;
>        LIST_ENTRY stape_mount_link;
>        struct timeval
>                stape_query_status_tod;
>
>        DEVBLK *firstdev;
>        DEVBLK *sysgdev;
>
>        DEVBLK ***devnum_fl;
>
>        DEVBLK ***subchan_fl;
>
>
>        U16 highsubchan[4];
>        U32 chp_reset[8];
>        IOINT *iointq;
>
>        DEVBLK *ioq;
>        LOCK ioqlock;
>        COND ioqcond;
>        int devtwait;
>        int devtnbr;
>        int devtmax;
>        int devthwm;
>        int devtunavail;
>
>        U64 addrlimval;
>
>        U16 servcode;
>        BYTE biosubcd;
>        BYTE biostat;
>        U64 bioparm;
>        DEVBLK *biodev;
>
>
>        U32 servparm;
>        unsigned int
>                daemon_mode:1,
>                panel_init:1,
>                npquiet:1,
>                sigintreq:1,
>                insttrace:1,
>                inststep:1,
>                shutdown:1,
>                shutfini:1,
>
>
>
>                main_clear:1,
>                xpnd_clear:1,
>                showregsfirst:1,
>                showregsnone:1,
>                nomountedtapereinit:1,
>
>                legacysenseid:1,
>
>
>                haveiplparm:1,
>
>                logoptnotime:1;
>        U32 ints_state;
>        CPU_BITMAP config_mask;
>        CPU_BITMAP started_mask;
>        CPU_BITMAP waiting_mask;
>        U64 traceaddr[2];
>        U64 stepaddr[2];
>
>        BYTE iplparmstring[64];
>
>
>
>
>        struct {
>            u_int level:16;
>            u_int debug:1;
>            u_int available:1;
>        } ecpsvm;
>
>
>        U64 pgminttr;
>        int pcpu;
>        int hercprio;
>        int todprio;
>        int cpuprio;
>        int devprio;
>        TID httptid;
>        U16 httpport;
>        int httpauth;
>        char *httpuser;
>        char *httppass;
>        char *httproot;
>
>        TAMDIR *tamdir;
>        char *defdir;
>
>
>        int syncing;
>        CPU_BITMAP sync_mask;
>        COND sync_cond;
>        COND sync_bc_cond;
>
>        int asnandlxreuse;
>
>
>        TID shrdtid;
>        U16 shrdport;
>        U32 shrdcount;
>        SHRD_TRACE *shrdtrace;
>        SHRD_TRACE *shrdtracep;
>        SHRD_TRACE *shrdtracex;
>        int shrdtracen;
>
>
>        int iodelay;
>
>
>
>
>
>        uid_t ruid, euid, suid;
>        gid_t rgid, egid, sgid;
># 692 "hstructs.h"
>        char *logofile;
>        char **herclogo;
>        size_t logolines;
>
>
>        U64 instcount;
>        U32 mipsrate;
>        U32 siosrate;
>
>
>
>        int cmdtgt;
>
>
>        int regs_copy_len;
>
>        REGS dummyregs;
>
>
>        int keep_timeout_secs;
>
>
>};
>
>
>
>
>
>struct IOINT {
>        IOINT *next;
>        DEVBLK *dev;
>        int priority;
>        unsigned int
>                pending:1,
>                pcipending:1,
>                attnpending:1;
>};
>
>
>
>
>
>
>
>  struct STSTATRQ
>  {
>      LIST_ENTRY link;
>      DEVBLK* dev;
>  };
>  typedef struct STSTATRQ STSTATRQ;
>
>  struct STMNTDRQ
>  {
>      LIST_ENTRY link;
>      DEVBLK* dev;
>  };
>  typedef struct STMNTDRQ STMNTDRQ;
>
>
>
>
>
>
>struct DEVBLK {
>
>
>        DEVBLK *nextdev;
>        REGS *regs;
>        LOCK lock;
>        int allocated;
>
>
>
>        U16 ssid;
>        U16 subchan;
>        U16 devnum;
>        U16 devtype;
>        U16 chanset;
>
>        char *typname;
>
>        int member;
>        DEVGRP *group;
>
>        int argc;
>        char **argv;
>
>
>
>        BYTE *mainstor;
>        BYTE *storkeys;
>        U64 mainlim;
>
>        char filename[4096 +1];
>
>
>
>        int fd;
>        FILE *fh;
>        bind_struct* bs;
>
>
>
>
>        int bufcur;
>        BYTE *buf;
>        int bufsize;
>        int buflen;
>        int bufoff;
>        int bufres;
>        int bufoffhi;
>        int bufupdlo;
>        int bufupdhi;
>        U32 bufupd;
>
>
>
>        int cache;
>        int cachehits;
>        int cachemisses;
>        int cachewaits;
>
>
>
>        int comps;
>        int comp;
>        int compoff;
>
>
>
>        TID tid;
>        int priority;
>        DEVBLK *nextioq;
>        IOINT ioint;
>
>        IOINT pciioint;
>
>        IOINT attnioint;
>
>        int cpuprio;
>        int devprio;
>
>
>        BYTE chained;
>
>        BYTE prev_chained;
>
>        BYTE code;
>        BYTE prevcode;
>        int ccwseq;
>
>        U32 ccwaddr;
>        U16 idapmask;
>        BYTE idawfmt;
>        BYTE ccwfmt;
>        BYTE ccwkey;
>
>
>
>        DEVHND *hnd;
>
>
>
>
>
>
>        void ( *halt_device)(DEVBLK *);
>
>        DEVIM *immed;
>
>        int is_immed;
>
>
>
>        int reserved1;
>        ORB orb;
>        PMCW pmcw;
>        SCSW scsw;
>        SCSW pciscsw;
>        SCSW attnscsw;
>        BYTE csw[8];
>        BYTE pcicsw[8];
>        BYTE attncsw[8];
>        ESW esw;
>        BYTE ecw[32];
>        U32 numsense;
>        BYTE sense[256];
>        U32 numdevid;
>        BYTE devid[256];
>        U32 numdevchar;
>        BYTE devchar[64];
>        BYTE pgstat;
>        BYTE pgid[11];
>        BYTE reserved2[4];
>        COND resumecond;
>        COND iocond;
>        int iowaiters;
>        int ioactive;
>
>
>        BYTE drvpwd[11];
>        BYTE reserved3;
>
>
>
>        unsigned int
>
>                ckdkeytrace:1,
>
>                syncio:2,
>                shared:1,
>                console:1,
>                connected:1,
>                readpending:2,
>                connecting:1,
>                localhost:1,
>                batch:1,
>                dasdcopy:1,
>                oslinux:1,
>                ccwtrace:1,
>                ccwstep:1,
>                cdwmerge:1;
>
>
>        unsigned int
>
>                busy:1,
>                reserved:1,
>                suspended:1,
>                pending:1,
>                pcipending:1,
>                attnpending:1,
>                startpending:1,
>                resumesuspended:1;
>
>
>
>        int crwpending;
>        int syncio_active;
>        int syncio_retry;
>
>
>
>        U32 syncio_addr;
>        U64 syncios;
>        U64 asyncios;
>
>
>        void *dev_data;
>
>
>
>        GUISTAT* pGUIStat;
>
>
>
>
>        struct VMBIOENV *vmd250env;
>
>
>
>
>        struct in_addr rmtaddr;
>        U16 rmtport;
>        U16 rmtnum;
>        int rmtid;
>        int rmtrel;
>        DBLWRD rmthdr;
>        int rmtcomp;
>        int rmtcomps;
>        int rmtpurgen;
>        FWORD *rmtpurge;
>
>
>
>        TID shrdtid;
>        int shrdid;
>        int shrdconn;
>        int shrdwait;
>        SHRD *shrd[8];
>
>
>
>
>        struct in_addr ipaddr;
>        in_addr_t acc_ipaddr;
>        in_addr_t acc_ipmask;
>        U32 rlen3270;
>        int pos3270;
>        int keybdrem;
>
>        u_int eab3270:1;
>        u_int ewa3270:1;
>        u_int prompt1052:1;
>        BYTE aid3270;
>        BYTE mod3270;
>
>
>
>        char **more_files;
>
>        char **current_file;
>
>        int cardpos;
>
>        int cardrem;
>
>        u_int multifile:1;
>        u_int rdreof:1;
>        u_int ebcdic:1;
>        u_int ascii:1;
>        u_int trunc:1;
>        u_int autopad:1;
>
>
>
>
>        DEVBLK *ctcpair;
>        int ctcpos;
>        int ctcrem;
>        int ctclastpos;
>        int ctclastrem;
>        u_int ctcxmode:1;
>        BYTE ctctype;
>        BYTE netdevname[16];
>
>
>
>        int printpos;
>
>        int printrem;
>
>        pid_t ptpcpid;
>        u_int crlf:1;
>        u_int diaggate:1;
>        u_int fold:1;
>        u_int ispiped:1;
>        u_int stopprt:1;
>        u_int notrunc:1;
>
>        u_int fcbsupp:1;
>        u_int cc:1;
>        u_int rawcc:1;
>        u_int fcbcheck:1;
>        u_int nofcbcheck:1;
>        u_int ccpend:1;
>        u_int chskip:1;
>
>        int print;
>        int browse;
>
>        int lpi;
>        int index;
>        int lpp;
>        int ffchan ;
>
>        int fcb[256 +1];
>        int fcbisdef;
>
>        int prevline;
>        int currline;
>        int destline;
>
>
>
>        void *omadesc;
>        U16 omafiles;
>        U16 curfilen;
>        U32 blockid;
>        off_t nxtblkpos;
>
>        off_t prvblkpos;
>
>        U16 curblkrem;
>
>        U16 curbufoff;
>
>        U16 tapssdlen;
>
>        HETB *hetb;
>
>        struct
>        {
>          u_int compress:1;
>          u_int method:3;
>          u_int level:4;
>          u_int strictsize:1;
>          u_int displayfeat:1;
>
>          u_int deonirq:1;
>
>          u_int logical_readonly:1;
>          U16 chksize;
>          off_t maxsize;
>
>        } tdparms;
>
>        off_t eotmargin;
>
>        u_int fenced:1;
>        u_int readonly:1;
>        u_int sns_pending:1;
>
>
>
>
>
>
>        u_int SIC_supported:1;
>        u_int SIC_active:1;
>        u_int forced_logging:1;
>        u_int eotwarning:1;
>
>        u_int noautomount:1;
>
>        u_int supvr_inhibit:1;
>        u_int write_immed:1;
>
>        struct mtget mtget;
>
>
>
>        u_int stape_close_rewinds:1;
>        u_int stape_blkid_32:1;
>        u_int stape_no_erg:1;
>
>        COND stape_sstat_cond;
>        STSTATRQ stape_statrq;
>        STMNTDRQ stape_mntdrq;
>
>        U32 msgid;
>        BYTE tapedevt;
>        TAPEMEDIA_HANDLER *tmh;
>
>
>
>        TAPEAUTOLOADENTRY *als;
>        int alss;
>        int alsix;
>        char **al_argv;
>        int al_argc;
>
>
>
>
>        char tapemsg1[9];
>        char tapemsg2[9];
>        char tapesysmsg[32];
>        char *prev_tapemsg;
>
>        BYTE tapedisptype;
>        BYTE tapedispflags;
># 1174 "hstructs.h"
>        COMMADPT *commadpt;
>
>
>
>        char *dasdsfn;
>        char *dasdsfx;
>
>
>
>
>        FBADEV *fbatab;
>        int fbanumblk;
>        int fbablksiz;
>        off_t fbaorigin;
>        off_t fbarba;
>        off_t fbaend;
>
>        u_int fbaxtdef:1;
>        BYTE fbamask;
>        U32 fbaxblkn;
>
>        U32 fbaxfirst;
>
>        U32 fbaxlast;
>
>
>        BYTE fbaoper;
>        U16 fbalcnum;
>        U32 fbalcblk;
>
>
>
>
>        int ckdnumfd;
>        int ckdfd[27];
>        int ckdhitrk[27];
>
>        CKDDEV *ckdtab;
>        CKDCU *ckdcu;
>        off_t ckdtrkoff;
>        int ckdcyls;
>        int ckdtrks;
>        int ckdheads;
>        int ckdtrksz;
>        int ckdcurcyl;
>        int ckdcurhead;
>        int ckdcurrec;
>        int ckdcurkl;
>        int ckdorient;
>        int ckdcuroper;
>        U16 ckdcurdl;
>        U16 ckdrem;
>
>        U16 ckdpos;
>
>        U16 ckdxblksz;
>        U16 ckdxbcyl;
>        U16 ckdxbhead;
>        U16 ckdxecyl;
>        U16 ckdxehead;
>        BYTE ckdfmask;
>        BYTE ckdxgattr;
>        U16 ckdltranlf;
>
>        U16 ckdlmask;
>        BYTE ckdloper;
>        BYTE ckdlaux;
>        BYTE ckdlcount;
>        BYTE ckdreserved1;
>        void *cckd_ext;
>
>        u_int ckd3990:1;
>        u_int ckdxtdef:1;
>        u_int ckdsetfm:1;
>        u_int ckdlocat:1;
>        u_int ckdspcnt:1;
>        u_int ckdseek:1;
>        u_int ckdskcyl:1;
>        u_int ckdrecal:1;
>        u_int ckdrdipl:1;
>        u_int ckdxmark:1;
>        u_int ckdhaeq:1;
>        u_int ckdideq:1;
>        u_int ckdkyeq:1;
>        u_int ckdwckd:1;
>        u_int ckdtrkof:1;
>        u_int ckdssi:1;
>        u_int ckdnolazywr:1;
>        u_int ckdrdonly:1;
>        u_int ckdwrha:1;
>
>        u_int ckdfakewr:1;
>
>        U16 ckdssdlen;
>
>};
>
>
>
>
>
>struct DEVGRP {
>        int members;
>        int acount;
>        void *grp_data;
>        DEVBLK *memdev[];
>};
>
>
>
>
>
>struct CKDDASD_DEVHDR {
>        BYTE devid[8];
>        FWORD heads;
>
>        FWORD trksize;
>        BYTE devtype;
>
>        BYTE fileseq;
>
>
>        HWORD highcyl;
>
>
>
>        BYTE resv[492];
>};
>
>struct CKDDASD_TRKHDR {
>        BYTE bin;
>        HWORD cyl;
>        HWORD head;
>};
>
>struct CKDDASD_RECHDR {
>        HWORD cyl;
>        HWORD head;
>        BYTE rec;
>        BYTE klen;
>        HWORD dlen;
>};
># 1334 "hstructs.h"
>struct CCKDDASD_DEVHDR {
>        BYTE vrm[3];
>        BYTE options;
>        S32 numl1tab;
>        S32 numl2tab;
>        U32 size;
>        U32 used;
>        U32 free;
>        U32 free_total;
>        U32 free_largest;
>        S32 free_number;
>        U32 free_imbed;
>        FWORD cyls;
>        BYTE nullfmt;
>        BYTE compress;
>        S16 compress_parm;
>        BYTE resv2[464];
>};
># 1379 "hstructs.h"
>struct CCKD_L2ENT {
>        U32 pos;
>        U16 len;
>        U16 size;
>};
>
>struct CCKD_FREEBLK {
>        U32 pos;
>        U32 len;
>};
>
>struct CCKD_IFREEBLK {
>        U32 pos;
>        U32 len;
>        int prev;
>        int next;
>        int pending;
>};
>
>struct CCKD_RA {
>        DEVBLK *dev;
>        int trk;
>        int prev;
>        int next;
>};
>
>typedef U32 CCKD_L1ENT;
>typedef CCKD_L1ENT CCKD_L1TAB[];
>typedef CCKD_L2ENT CCKD_L2TAB[256];
>typedef char CCKD_TRACE[128];
># 1465 "hstructs.h"
>struct CCKDBLK {
>        BYTE id[8];
>        DEVBLK *dev1st;
>        unsigned int batch:1,
>                         sfmerge:1,
>                         sfforce:1;
>        int sflevel;
>
>        BYTE comps;
>        BYTE comp;
>        int compparm;
>
>        LOCK gclock;
>        COND gccond;
>        int gcs;
>        int gcmax;
>        int gcwait;
>        int gcparm;
>
>        LOCK wrlock;
>        COND wrcond;
>        int wrpending;
>        int wrwaiting;
>        int wrs;
>        int wrmax;
>        int wrprio;
>
>        LOCK ralock;
>        COND racond;
>        int ras;
>        int ramax;
>        int rawaiting;
>        int ranbr;
>        int readaheads;
>        CCKD_RA ra[16];
>        int ra1st;
>        int ralast;
>        int rafree;
>
>        LOCK devlock;
>        COND devcond;
>        int devusers;
>        int devwaiters;
>
>        int freepend;
>        int nostress;
>        int linuxnull;
>        int fsync;
>        COND termcond;
>
>        U64 stats_switches;
>        U64 stats_cachehits;
>        U64 stats_cachemisses;
>        U64 stats_readaheads;
>        U64 stats_readaheadmisses;
>        U64 stats_syncios;
>        U64 stats_synciomisses;
>        U64 stats_iowaits;
>        U64 stats_cachewaits;
>        U64 stats_stresswrites;
>        U64 stats_l2cachehits;
>        U64 stats_l2cachemisses;
>        U64 stats_l2reads;
>        U64 stats_reads;
>        U64 stats_readbytes;
>        U64 stats_writes;
>        U64 stats_writebytes;
>        U64 stats_gcolmoves;
>        U64 stats_gcolbytes;
>
>        CCKD_TRACE *itrace;
>        CCKD_TRACE *itracep;
>        CCKD_TRACE *itracex;
>        int itracen;
>
>        int bytemsgs;
>};
>
>struct CCKDDASD_EXT {
>        DEVBLK *devnext;
>        unsigned int ckddasd:1,
>                         fbadasd:1,
>                         ioactive:1,
>                         bufused:1,
>                         updated:1,
>                         merging:1,
>                         stopping:1,
>                         notnull:1,
>                         l2ok:1,
>                         sfmerge:1,
>                         sfforce:1;
>        int sflevel;
>        LOCK filelock;
>        LOCK iolock;
>        COND iocond;
>        long long maxsize;
>        int iowaiters;
>        int wrpending;
>        int ras;
>        int sfn;
>        int sfx;
>        int l1x;
>        CCKD_L2ENT *l2;
>        int l2active;
>        off_t l2bounds;
>        int active;
>        BYTE *newbuf;
>        unsigned int freemin;
>        CCKD_IFREEBLK *free;
>        int freenbr;
>        int free1st;
>        int freelast;
>        int freeavail;
>        int lastsync;
>        int ralkup[16];
>        int ratrk;
>        unsigned int totreads;
>        unsigned int totwrites;
>        unsigned int totl2reads;
>        unsigned int cachehits;
>        unsigned int readaheads;
>        unsigned int switches;
>        unsigned int misses;
>        int fd[8 +1];
>        BYTE swapend[8 +1];
>        BYTE open[8 +1];
>        int reads[8 +1];
>        int l2reads[8 +1];
>        int writes[8 +1];
>        CCKD_L1ENT *l1[8 +1];
>        CCKDDASD_DEVHDR cdevhdr[8 +1];
>};
>
>
>
>
>
>
>
>struct GUISTAT
>{
>    char* pszOldStatStr;
>    char* pszNewStatStr;
>
>    char szStatStrBuff1[256];
>    char szStatStrBuff2[256];
>};
># 130 "hercules.h" 2
># 1 "hexterns.h" 1
>
>
>
>
>
>
># 1 "hercules.h" 1
>
>
>
>
>
>
>
># 1 "./config.h" 1
># 9 "hercules.h" 2
># 47 "hercules.h"
># 1 "feature.h" 1
>
>
>
>
># 1 "./config.h" 1
># 6 "feature.h" 2
># 26 "feature.h"
># 1 "featall.h" 1
># 27 "feature.h" 2
>
>
># 1 "feat370.h" 1
># 30 "feature.h" 2
># 38 "feature.h"
># 1 "featchk.h" 1
># 39 "feature.h" 2
># 48 "hercules.h" 2
>
>
>
>
>
># 1 "cpuint.h" 1
># 54 "hercules.h" 2
># 8 "hexterns.h" 2
># 150 "hexterns.h"
>int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid);
>int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid);
>int setresuid(uid_t ruid, uid_t euid, uid_t suid);
>int setresgid(gid_t rgid, gid_t egid, gid_t sgid);
># 166 "hexterns.h"
>extern SYSBLK sysblk;
>extern CCKDBLK cckdblk;
>
>extern int extgui;
>
>
>
>
>
>void build_config (char *fname);
>void release_config ();
>extern DEVBLK *find_device_by_devnum (U16 lcss, U16 devnum);
>DEVBLK *find_device_by_subchan (U32 ioid);
>REGS *devregs(DEVBLK *dev);
>DEVBLK *get_devblk (U16 lcss, U16 devnum);
>void ret_devblk (DEVBLK *dev);
>int attach_device (U16 lcss, U16 devnum, const char *devtype, int addargc,
>        char *addargv[]);
>int detach_subchan (U16 lcss, U16 subchan);
>int detach_device (U16 lcss, U16 devnum);
>int define_device (U16 lcss, U16 olddev, U16 newdev);
>extern int group_device(DEVBLK *dev, int members);
>int configure_cpu (int cpu);
>int deconfigure_cpu (int cpu);
>extern int parse_args (char* p, int maxargc, char** pargv, int* pargc);
>
>int parse_and_attach_devices(const char *devnums,const char *devtype,int ac,char **av);
>extern int parse_single_devnum(const char *spec, U16 *lcss, U16 *devnum);
>int parse_single_devnum_silent(const char *spec, U16 *lcss, U16 *devnum);
>int readlogo(char *fn);
>void clearlogo(void);
>extern int parse_conkpalv(char* s, int* idle, int* intv, int* cnt );
>
>extern int add_tamdir( char *tamdir, TAMDIR **ppTAMDIR );
>
>
>
>extern const char* arch_name[];
>extern const char* get_arch_mode_string(REGS* regs);
>
>
>void expire_kept_msgs(int unconditional);
>
>extern U32 maxrates_rpt_intvl;
>extern U32 curr_high_mips_rate;
>extern U32 curr_high_sios_rate;
>extern U32 prev_high_mips_rate;
>extern U32 prev_high_sios_rate;
>extern time_t curr_int_start_time;
>extern time_t prev_int_start_time;
>extern void update_maxrates_hwm();
>
>
>
>
>extern int hao_initialize(void);
>extern void hao_command(char *command);
>extern void hao_message(char *message);
>
>
>
>extern int aia_cmd (int argc, char *argv[], char *cmdline);
>extern int stopall_cmd (int argc, char *argv[], char *cmdline);
>
>
>extern int ProcessConfigCommand (int argc, char **argv, char *cmdline);
>
>
>void losc_set (int license_status);
>void losc_check(char *ostype);
>
>
>
>extern char *(*hdl_device_type_equates) (const char *);
>extern void *(panel_command_r) (void *cmdline);
>extern void (panel_display_r) (void);
>
>extern int (*config_command) (int argc, char *argv[], char *cmdline);
>extern int (*system_command) (int argc, char *argv[], char *cmdline);
>extern void (*daemon_task) (void);
>extern void (*panel_display) (void);
>extern void *(*panel_command) (void *);
>
>extern void *(*debug_device_state) (DEVBLK *);
>extern void *(*debug_cpu_state) (REGS *);
>extern void *(*debug_cd_cmd) (char *);
>extern void *(*debug_watchdog_signal) (REGS *);
>extern void *(*debug_program_interrupt) (REGS *, int);
>extern void *(*debug_diagnose) (U32, int, int, REGS *);
>extern void *(*debug_iucv) (int, U32, REGS *);
>extern void *(*debug_sclp_unknown_command) (U32, void *, REGS *);
>extern void *(*debug_sclp_unknown_event) (void *, void *, REGS *);
>extern void *(*debug_sclp_unknown_event_mask) (void *, void *, REGS *);
>extern void *(*debug_chsc_unknown_request) (void *, void *, REGS *);
>extern void *(*debug_sclp_event_data) (void *, void *, REGS *);
># 279 "hexterns.h"
>void set_loadparm(char *name);
>void get_loadparm(BYTE *dest);
>char *str_loadparm();
>void set_lparname(char *name);
>void get_lparname(BYTE *dest);
>extern char *str_lparname();
>void set_manufacturer(char *name);
>void set_plant(char *name);
>void set_model(int argc, char *m1, char* m2, char* m3, char* m4);
>void get_manufacturer(BYTE *name);
>void get_plant(BYTE *name);
>void get_model(BYTE *name);
>void get_modelcapa(BYTE *name);
>void get_modelperm(BYTE *name);
>void get_modeltemp(BYTE *name);
>void get_sysname(BYTE *name);
>void get_systype(BYTE *name);
>void get_sysplex(BYTE *name);
>void set_sysname(BYTE *name);
>void set_systype(BYTE *name);
>void set_sysplex(BYTE *name);
>void get_mpfactors(BYTE *dest);
>
>
>extern void system_cleanup(void);
>
>typedef void (*LOGCALLBACK)(const char *,size_t);
>typedef void *(*COMMANDHANDLER)(void *);
>
>extern int impl(int,char **);
>extern void regiserLogCallback(LOGCALLBACK);
>extern COMMANDHANDLER getCommandHandler(void);
>
>
>void update_TOD_clock (void);
>void *timer_update_thread (void *argp);
>
>
>void scp_command (char *command, int priomsg);
>int can_signal_quiesce ();
>int signal_quiesce (U16 count, BYTE unit);
>void sclp_attention(U16 type);
>void sclp_reset();
>extern void sclp_sysg_attention();
>int servc_hsuspend(void *file);
>int servc_hresume(void *file);
>
>
>void ckd_build_sense ( DEVBLK *, BYTE, BYTE, BYTE, BYTE, BYTE);
>int ckddasd_init_handler ( DEVBLK *dev, int argc, char *argv[]);
>void ckddasd_execute_ccw ( DEVBLK *dev, BYTE code, BYTE flags,
>        BYTE chained, U16 count, BYTE prevcode, int ccwseq,
>        BYTE *iobuf, BYTE *more, BYTE *unitstat, U16 *residual );
>int ckddasd_close_device ( DEVBLK *dev );
>void ckddasd_query_device (DEVBLK *dev, char **class,
>                int buflen, char *buffer);
>int ckddasd_hsuspend ( DEVBLK *dev, void *file );
>int ckddasd_hresume ( DEVBLK *dev, void *file );
>
>
>extern void fbadasd_syncblk_io (DEVBLK *dev, BYTE type, int blknum,
>        int blksize, BYTE *iobuf, BYTE *unitstat, U16 *residual);
>extern void fbadasd_read_block
>      ( DEVBLK *dev, int blknum, int blksize, int blkfactor,
>        BYTE *iobuf, BYTE *unitstat, U16 *residual );
>extern void fbadasd_write_block
>      ( DEVBLK *dev, int blknum, int blksize, int blkfactor,
>        BYTE *iobuf, BYTE *unitstat, U16 *residual );
>int fbadasd_init_handler ( DEVBLK *dev, int argc, char *argv[]);
>void fbadasd_execute_ccw ( DEVBLK *dev, BYTE code, BYTE flags,
>        BYTE chained, U16 count, BYTE prevcode, int ccwseq,
>        BYTE *iobuf, BYTE *more, BYTE *unitstat, U16 *residual );
>int fbadasd_close_device ( DEVBLK *dev );
>void fbadasd_query_device (DEVBLK *dev, char **class,
>                int buflen, char *buffer);
>int fbadasd_hsuspend ( DEVBLK *dev, void *file );
>int fbadasd_hresume ( DEVBLK *dev, void *file );
>
>
>DEVIF cckddasd_init_handler;
>int cckddasd_close_device (DEVBLK *);
>int cckd_read_track (DEVBLK *, int, BYTE *);
>int cckd_update_track (DEVBLK *, int, int, BYTE *, int, BYTE *);
>int cfba_read_block (DEVBLK *, int, BYTE *);
>int cfba_write_block (DEVBLK *, int, int, BYTE *, int, BYTE *);
>extern void *cckd_sf_add (void *);
>extern void *cckd_sf_remove (void *);
>extern void *cckd_sf_stats (void *);
>extern void *cckd_sf_comp (void *);
>extern void *cckd_sf_chk (void *);
>extern int cckd_command(char *, int);
>extern void cckd_print_itrace ();
>
>
>extern int cckd_swapend (DEVBLK *);
>extern void cckd_swapend_chdr (CCKDDASD_DEVHDR *);
>extern void cckd_swapend_l1 (CCKD_L1ENT *, int);
>extern void cckd_swapend_l2 (CCKD_L2ENT *);
>extern void cckd_swapend_free (CCKD_FREEBLK *);
>extern void cckd_swapend4 (char *);
>extern void cckd_swapend2 (char *);
>extern int cckd_endian ();
>extern int cckd_comp (DEVBLK *);
>extern int cckd_chkdsk (DEVBLK *, int);
>extern void cckdumsg (DEVBLK *, int, char *, ...);
>
>
>int herc_system (char* command);
>void do_shutdown();
>void display_regs (REGS *regs);
>void display_fregs (REGS *regs);
>void display_cregs (REGS *regs);
>void display_aregs (REGS *regs);
>void display_subchannel (DEVBLK *dev);
>void get_connected_client (DEVBLK* dev, char** pclientip, char** pclientname);
>void alter_display_real (char *opnd, REGS *regs);
>void alter_display_virt (char *opnd, REGS *regs);
>void disasm_stor(REGS *regs, char *opnd);
>int drop_privileges(int capa);
>
>
>int suspend_cmd(int argc, char *argv[],char *cmdline);
>int resume_cmd(int argc, char *argv[],char *cmdline);
>
>
>
>
>
>int ecpsvm_dosvc(REGS *regs, int svccode);
>int ecpsvm_dossm(REGS *regs,int b,U32 ea);
>int ecpsvm_dolpsw(REGS *regs,int b,U32 ea);
>int ecpsvm_dostnsm(REGS *regs,int b,U32 ea,int imm);
>int ecpsvm_dostosm(REGS *regs,int b,U32 ea,int imm);
>int ecpsvm_dosio(REGS *regs,int b,U32 ea);
>int ecpsvm_dodiag(REGS *regs,int r1,int r3,int b2,U32 effective_addr2);
>int ecpsvm_dolctl(REGS *regs,int r1,int r3,int b2,U32 effective_addr2);
>int ecpsvm_dostctl(REGS *regs,int r1,int r3,int b2,U32 effective_addr2);
>int ecpsvm_doiucv(REGS *regs,int b2,U32 effective_addr2);
>int ecpsvm_virttmr_ext(REGS *regs);
># 428 "hexterns.h"
>void renew_wrapping_keys(void);
># 131 "hercules.h" 2
># 41 "cpu.c" 2
># 1 "opcode.h" 1
># 2736 "opcode.h"
>int s370_startio (REGS *regs, DEVBLK *dev, ORB *orb);
>void *s370_execute_ccw_chain (DEVBLK *dev);
>void *s390_execute_ccw_chain (DEVBLK *dev);
>void *z900_execute_ccw_chain (DEVBLK *dev);
>int stchan_id (REGS *regs, U16 chan);
>int testch (REGS *regs, U16 chan);
>int testio (REGS *regs, DEVBLK *dev, BYTE ibyte);
>int test_subchan (REGS *regs, DEVBLK *dev, IRB *irb);
>int cancel_subchan (REGS *regs, DEVBLK *dev);
>void clear_subchan (REGS *regs, DEVBLK *dev);
>int halt_subchan (REGS *regs, DEVBLK *dev);
>int haltio (REGS *regs, DEVBLK *dev, BYTE ibyte);
>int resume_subchan (REGS *regs, DEVBLK *dev);
>int s370_present_io_interrupt (REGS *regs, U32 *ioid,
>        U32 *ioparm, U32 *iointid, BYTE *csw);
>int s370_present_zone_io_interrupt (U32 *ioid, U32 *ioparm,
>                                              U32 *iointid, BYTE zone);
>void io_reset (void);
>int chp_reset(REGS *, BYTE chpid);
>void channelset_reset(REGS *regs);
> int device_attention (DEVBLK *dev, BYTE unitstat);
> int s370_device_attention (DEVBLK *dev, BYTE unitstat);
>
>
>
>
>
>
>void s370_store_psw (REGS *regs, BYTE *addr);
>int s370_load_psw (REGS *regs, BYTE *addr);
>void s370_process_trace (REGS *regs);
>
>
>int s390_load_psw (REGS *regs, BYTE *addr);
>void s390_store_psw (REGS *regs, BYTE *addr);
>void s390_process_trace (REGS *regs);
>
>
>int z900_load_psw (REGS *regs, BYTE *addr);
>void z900_store_psw (REGS *regs, BYTE *addr);
>void z900_process_trace (REGS *regs);
>
>
>int cpu_init (int cpu, REGS *regs, REGS *hostregs);
>void s370_perform_io_interrupt (REGS *regs);
>void s370_checkstop_config(void);
>
> void (__attribute__ (( regparm(2) )) s370_program_interrupt) (REGS *regs, int code);
>
>
> void (__attribute__ (( regparm(2) )) s390_program_interrupt) (REGS *regs, int code);
>
> void (__attribute__ (( regparm(2) )) s370_program_interrupt) (REGS *regs, int code);
>void *cpu_thread (int *cpu);
> void copy_psw (REGS *regs, BYTE *addr);
>void display_psw (REGS *regs);
>
>
>
>int s370_diag_devtype (int r1, int r2, REGS *regs);
>int s370_syncblk_io (int r1, int r2, REGS *regs);
>int s370_syncgen_io (int r1, int r2, REGS *regs);
>void s370_extid_call (int r1, int r2, REGS *regs);
>int s370_cpcmd_call (int r1, int r2, REGS *regs);
>void s370_pseudo_timer (U32 code, int r1, int r2, REGS *regs);
>void s370_access_reipl_data (int r1, int r2, REGS *regs);
>int s370_diag_ppagerel (int r1, int r2, REGS *regs);
>void s370_vm_info (int r1, int r2, REGS *regs);
>int s370_device_info (int r1, int r2, REGS *regs);
>
>
>
>int s370_vm_blockio (int r1, int r2, REGS *regs);
>
>
>
>void s370_load_real_address_proc (REGS *regs,
>    int r1, int b2, U32 effective_addr2);
>
>
>
>void packed_to_binary (BYTE *dec, int len, U64 *result,
>    int *ovf, int *dxf);
>void binary_to_packed (S64 bin, BYTE *result);
>
>
>
>void s370_diagnose_call (U32 effective_addr2, int b2, int r1, int r3,
>    REGS *regs);
>
>
>
>void s370_scpend_call (void);
>int s370_mssf_call (int r1, int r2, REGS *regs);
>void s370_diag204_call (int r1, int r2, REGS *regs);
>void s370_diag224_call (int r1, int r2, REGS *regs);
>
>
>
>void s370_perform_external_interrupt (REGS *regs);
>void s370_store_status (REGS *ssreg, U64 aaddr);
>void store_status (REGS *ssreg, U64 aaddr);
>
>
>
>int load_ipl (U16 lcss, U16 devnum, int cpu, int clear);
>int s370_load_ipl (U16 lcss, U16 devnum, int cpu, int clear);
>int system_reset (int cpu, int clear);
>int s370_system_reset (int cpu, int clear);
>int cpu_reset (REGS *regs);
>int s370_cpu_reset (REGS *regs);
>int initial_cpu_reset (REGS *regs);
>int s370_initial_cpu_reset (REGS *regs);
>int s370_common_load_begin (int cpu, int clear);
>int s370_common_load_finish (REGS *regs);
>void storage_clear(void);
>void xstorage_clear(void);
>
>
>
>void set_sce_dir (char *path);
>char *get_sce_dir ();
>int load_main (char *fname, U64 startloc);
>int s370_load_main (char *fname, U64 startloc);
>int load_hmc (char *fname, int cpu, int clear);
>int s370_load_hmc (char *fname, int cpu, int clear);
>void s370_sclp_scedio_request (SCCB_HEADER *);
>void s370_sclp_scedio_event (SCCB_HEADER *);
>
>
>
>int s370_present_mck_interrupt (REGS *regs, U64 *mcic, U32 *xdmg,
>    U64 *fsta);
>U32 channel_report (REGS *);
>void machine_check_crwpend (void);
>void s370_sync_mck_interrupt (REGS *regs);
>void sigabend_handler (int signo);
>
>
>
>extern void copy_opcode_tables ();
>void set_opcode_pointers (REGS *regs);
>
>
>
>void s370_display_inst (REGS *regs, BYTE *inst);
>void display_inst (REGS *regs, BYTE *inst);
>
>
>
>void s370_sie_exit (REGS *regs, int code);
>void s370_diagnose_002 (REGS *regs, int r1, int r3);
>
>
>
>void s370_trap_x (int trap_is_trap4, REGS *regs, U32 trap_operand);
>void s370_form_stack_entry (BYTE etype, U32 retna, U32 calla,
>    U32 csi, U32 pcnum, REGS *regs);
>U32 s370_locate_stack_entry (int prinst, LSED *lsedptr,
>    REGS *regs);
>void s370_stack_modify (U32 lsea, U32 m1, U32 m2, REGS *regs);
>void s370_stack_extract (U32 lsea, int r1, int code, REGS *regs);
>void s370_unstack_registers (int gtype, U32 lsea, int r1,
>    int r2, REGS *regs);
>int s370_program_return_unstack (REGS *regs, U64 *lsedap, int *rc);
>
>
>
>U32 s370_trace_br (int amode, U32 ia, REGS *regs);
>
>U32 s390_trace_br (int amode, U32 ia, REGS *regs);
>
>U32 s370_trace_bsg (U32 alet, U32 ia, REGS *regs);
>U32 s370_trace_ssar (int ssair, U16 sasn, REGS *regs);
>U32 s370_trace_pc (U32 pcea, REGS *regs);
>U32 s370_trace_pr (REGS *newregs, REGS *regs);
>U32 s370_trace_pt (int pti, U16 pasn, U32 gpr2, REGS *regs);
>U32 s370_trace_tr (int r1, int r3, U32 op, REGS *regs);
>U32 s370_trace_tg (int r1, int r3, U32 op, REGS *regs);
>U32 s370_trace_ms (int br_ind, U32 ia, REGS *regs);
>
>
>
>int s370_plo_cl (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_clg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_clgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_clx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_cs (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_dcs (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_dcsg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_dcsgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_dcsx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csst (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csstg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csstgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csstx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csdst (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csdstg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csdstgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_csdstx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_cstst (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_cststg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_cststgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s370_plo_cststx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_execute_01xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_a4xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_a5xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_a6xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_a7xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_b2xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_b3xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_b9xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_c0xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_e3xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_e4xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_e5xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_ebxx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_ecxx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_edxx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_operation_exception) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_dummy_instruction) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_fix_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_svc_assist) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_obtain_local_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_release_local_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_obtain_cms_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_release_cms_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace_svc_interruption) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace_program_interruption) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace_initial_srb_dispatch) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace_io_interruption) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace_task_dispatch) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace_svc_return) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_compression_call) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_cipher_message_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_cipher_message_with_chaining_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compute_intermediate_message_digest_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compute_last_message_digest_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compute_message_authentication_code_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_perform_cryptographic_key_management_operation_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_cipher_message_with_cipher_feedback_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_cipher_message_with_counter_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_cipher_message_with_output_feedback_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_perform_cryptographic_computation_r) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_branch_and_set_authority) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_in_subspace_group) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_and_stack) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_swap_and_purge) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_diagnose) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_primary_asn) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_primary_asn_and_instance) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_secondary_asn) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_secondary_asn_and_instance) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_stacked_registers) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_stacked_state) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_address_space_control) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_psw_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_storage_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_storage_key_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_virtual_storage_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_invalidate_page_table_entry) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_address_space_parameters) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_control) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_program_status_word) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_real_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_using_real_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_lock_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_modify_stacked_state) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_to_primary) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_to_secondary) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_with_destination_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_with_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_with_optional_specifications) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_with_source_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_program_call) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_program_return) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_program_transfer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_program_transfer_with_instance) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_purge_accesslist_lookaside_buffer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_purge_translation_lookaside_buffer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_reset_reference_bit) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_reset_reference_bit_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_address_space_control) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_address_space_control_fast) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_clock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_clock_comparator) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_clock_programmable_field) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_cpu_timer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_prefix) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_psw_key_from_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_secondary_asn) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_secondary_asn_with_instance) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_storage_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_storage_key_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_system_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_signal_processor) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_clock_comparator) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_control) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_cpu_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_cpu_id) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_cpu_timer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_prefix) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_system_information) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_then_and_system_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_then_or_system_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_using_real_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_access) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_block) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_protection) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_add_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_edit_x_edit_and_mark) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_and_round_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_zero_and_add) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_decimal) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_inter_user_communication_vehicle) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_start_interpretive_execution) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_zone_parameter) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_zone_parameter) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_pending_zone_interrupt) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_signal_adapter) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_load_positive_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_halve_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_unnormal_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_unnormal_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_halve_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_unnormal_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_unnormal_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_unnormal_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_unnormal_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_short_to_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_unnormal_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_unnormal_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_float_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_float_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_float_short_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_float_ext_to_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fixed_to_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fixed_to_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fixed_to_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_short_to_fixed_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_long_to_fixed_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_ext_to_fixed_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_short_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_long_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_ext_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_float_short_to_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_float_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_float_short_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_zero_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_zero_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_zero_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_unnormal_float_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_unnormal_float_long_to_ext_low_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_unnormal_float_long_to_ext_high_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_unnormal_float_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_unnormal_float_long_to_ext_low_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_unnormal_float_long_to_ext_high_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_unnormal_float_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_unnormal_float_long_to_ext_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_unnormal_float_long_to_ext_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_unnormal_float_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_unnormal_float_long_to_ext_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_unnormal_float_long_to_ext_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_float_long_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_float_short_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_float_long_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_float_short_y) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_add_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_and_link_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_and_link) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_and_save_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_and_save) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_and_save_and_set_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_and_set_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_condition_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_condition) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_count_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_count) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_index_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_index_low_or_equal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_condition) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_and_save) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_count) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_index_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_index_low_or_equal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_checksum) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_form_codeword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_swap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_double_and_swap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_swap_and_store) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_characters_under_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_character_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_long_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_string) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_until_substring_equal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_utf16_to_utf8) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_utf16_to_utf32) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_utf32_to_utf16) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_utf32_to_utf8) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_utf8_to_utf16) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_utf8_to_utf32) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_to_binary) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_to_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_copy_access) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_execute_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_access_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_characters_under_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_program_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_access_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_address_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_monitor_call) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_inverse) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_long_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_numerics) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_string) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_with_offset) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_zones) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_or_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_perform_locked_operation) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_pack) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_search_string) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_search_string_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_access_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_program_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_double) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_double_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_single) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_single_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_double) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_double_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_single) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_single_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_access_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_characters_under_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_clock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_clock_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_clock_fast) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_supervisor_call) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_and_set) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_under_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_under_mask_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_under_mask_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_and_test) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_and_test_reverse) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_and_test_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_and_test_reverse_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_unpack) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_update_tree) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_add_immediate_long_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_immediate_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_with_signed_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_with_signed_immediate_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_branch_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_branch_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_branch_relative_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_branch_relative_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_trap_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_trap_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_immediate_halfword_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_immediate_long_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_immediate_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_immediate_and_branch) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_immediate_and_branch_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_immediate_and_branch_relative) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_immediate_and_branch_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_immediate_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_immediate_and_trap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_branch_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_branch_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_branch_relative_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_branch_relative_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_trap_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_trap_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_and_branch) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_and_branch_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_and_branch_relative) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_and_branch_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_and_trap_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_and_trap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_fullword_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_halfword_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_long_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_relative_long_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_relative_long_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_relative_long_long_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_relative_long_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_cache_attribute) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_address_extended_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_halfword_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_halfword_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_halfword_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_halfword_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_relative_long_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_relative_long_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_fullword_from_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_halfword_from_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_long_from_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_immediate_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_immediate_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_prefetch_data) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_prefetch_data_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_then_and_selected_bits_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_then_exclusive_or_selected_bits_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_then_insert_selected_bits_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_then_or_selected_bits_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_halfword_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_relative_long_long) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_add_high_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_high_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_high_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_high_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_high_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_with_signed_immediate_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_with_signed_immediate_high_n) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_count_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_high_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_high_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_byte_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fullword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_halfword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_character_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_halfword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_then_insert_selected_bits_high_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_then_insert_selected_bits_low_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_character_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_fullword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_halfword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_high_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_high_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_high_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_high_high_low_register) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_load_and_add) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_add_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_add_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_add_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_and) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_and_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_exclusive_or) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_exclusive_or_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_or) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_or_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_pair_disjoint) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_pair_disjoint_long) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_load_on_condition_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_on_condition_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_on_condition) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_on_condition_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_on_condition) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_on_condition_long) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_add_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_distinct_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_distinct_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_distinct_signed_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_distinct_long_signed_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_single_distinct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_single_distinct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_single_logical_distinct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_single_logical_distinct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_distinct_long_register) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_population_count) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_load_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fullword_high_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_fullword_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_thirtyone_and_trap) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_and_trap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_then_insert_selected_bits_long_reg_n) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s370_branch_prediction_preload) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_prediction_relative_preload) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_next_instruction_access_intent) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_clear_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_halt_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_modify_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_resume_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_address_limit) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_channel_monitor) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_reset_channel_path) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_start_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_cancel_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_channel_path_status) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_channel_report_word) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_pending_interruption) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_start_io) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_io) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_halt_io) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_channel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_channel_id) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_connect_channel_set) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_disconnect_channel_set) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_service_call) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_channel_subsystem_call) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_page_in) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_page_out) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_invalidate_expanded_storage_block_entry) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_v_test_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_complement_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_count_left_zeros_in_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_count_ones_in_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_extract_vct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_extract_vector_modes) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_restore_vr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_save_changed_vr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_save_vr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_load_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_load_vmr_complement) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_store_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_and_to_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_or_to_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_exclusive_or_to_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_save_vsr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_save_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_restore_vsr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_restore_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_load_vct_from_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_clear_vr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_set_vector_mask_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_load_vix_from_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_store_vector_parameters) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_save_vac) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_v_restore_vac) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_store_fpc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fpc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_fpc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_fpc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_bfp_rounding_mode_2bit) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_bfp_rounding_mode_3bit) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trap2) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trap4) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_resume_program) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_trace_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_to_binary_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_to_decimal_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_carry_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_borrow_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_carry_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_borrow_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_carry_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_borrow_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_carry) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_borrow) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_single_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_single_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_single_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_single_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_pair_to_quadword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_pair_from_quadword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_stacked_registers_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_psw) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_and_set_extended_authority) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_address_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_perform_frame_management_function) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_perform_timing_facility_function) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_perform_topology_function) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_reset_reference_bits_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_facility_list) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_facility_list_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_control_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_control_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_multiple_disjoint) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_multiple_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_multiple_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_multiple_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_multiple_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_using_real_address_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_using_real_address_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_addressing_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_addressing_mode_24) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_addressing_mode_31) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_addressing_mode_64) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_program_status_word_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_real_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_left_single_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_rotate_left_single_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_single_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_single_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_right_single_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_left_single_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_thirtyone_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_under_mask_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_under_mask_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_count_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_real_address_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_count_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_count_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_swap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_double_and_swap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_index_high_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_on_index_low_or_equal_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_index_high_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_index_low_or_equal_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_characters_under_mask_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_characters_under_mask_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_characters_under_mask_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_on_condition_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_branch_relative_and_save_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_thirtyone) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_immediate_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_immediate_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_immediate_low_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_immediate_low_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate_low_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate_low_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate_low_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate_low_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_immediate_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_immediate_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_immediate_low_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_immediate_low_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_reversed_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_reversed_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_reversed_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_reversed) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_reversed_half) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_reversed_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_reversed) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_reversed_half) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_pack_ascii) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_pack_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_unpack_ascii) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_unpack_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_two_to_two) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_two_to_one) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_one_to_two) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_translate_one_to_one) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_long_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_long_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_swap_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_double_and_swap_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_characters_under_mask_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_to_binary_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_to_decimal_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_character_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_characters_under_mask_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_access_multiple_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_address_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_byte) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_byte_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_multiple_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_real_address_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_move_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_single_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_access_multiple_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_character_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_characters_under_mask_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_store_multiple_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_under_mask_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_swap_and_purge_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_invalidate_dat_table_entry) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_replace_dat_table_entry) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_page_table_entry_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_logical_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_and_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_logical_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_exclusive_or_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_or_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_logical_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_byte_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_byte_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_halfword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_long_halfword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_character_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_character_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_halfword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_logical_long_halfword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_find_leftmost_one_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_cpu_time) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_program_parameter) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_basic_freex) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_basic_fretx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_lock_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_unlock_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_decode_next_ccw) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_free_ccwstor) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_locate_vblock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_disp1) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_tpage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_tpage_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_inval_segtab) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_inval_ptable) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_decode_first_ccw) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_dispatch_main) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_locate_rblock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_comm_ccwproc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_unxlate_ccw) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_disp2) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_store_level) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_loc_chgshrpg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_extended_freex) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_extended_fretx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_ecpsvm_prefmach_assist) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_long_to_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_short_to_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_long_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_float_long_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_signal_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_signal_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_signal_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_signal_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_signal_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix32_to_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix32_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix32_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u32_to_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u32_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u32_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u64_to_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u64_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u64_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_ext_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_long_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_short_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_ext_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_long_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_short_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_ext_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_long_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_short_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_ext_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_long_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_bfp_short_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_integer_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_integer_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_bfp_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_bfp_short_to_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_bfp_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_bfp_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_bfp_short_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_bfp_short_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_bfp_long_to_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_bfp_ext_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_bfp_ext_to_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_short_to_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_add_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_subtract_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_squareroot_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_class_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_class_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_class_bfp_ext) (BYTE inst[], REGS *regs);
>
>
>void (__attribute__ (( regparm(2) )) s370_copy_sign_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_complement_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fpr_from_gr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_gr_from_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_negative_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_positive_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_dfp_rounding_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fpc_and_signal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_set_fpc_and_signal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_add_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_signal_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_and_signal_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_exponent_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_compare_exponent_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix32_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix32_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u32_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u32_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_fix64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u64_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_u64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_sbcd128_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_sbcd64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_ubcd128_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_ubcd64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_zoned_to_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_zoned_to_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_ext_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_long_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_ext_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_long_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_ext_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_long_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_ext_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_long_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_ext_to_sbcd128_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_long_to_sbcd64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_ext_to_ubcd128_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_long_to_ubcd64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_ext_to_zoned) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_convert_dfp_long_to_zoned) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_divide_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_biased_exponent_dfp_ext_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_biased_exponent_dfp_long_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_significance_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_significance_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_biased_exponent_fix64_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_insert_biased_exponent_fix64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_and_test_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_fp_int_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_dfp_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_lengthened_dfp_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_dfp_ext_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_load_rounded_dfp_long_to_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_multiply_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_quantize_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_quantize_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_reround_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_reround_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_coefficient_left_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_coefficient_left_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_coefficient_right_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_shift_coefficient_right_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_subtract_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_class_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_class_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_class_dfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_group_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_group_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_test_data_group_dfp_short) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_perform_floating_point_operation) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s370_perform_processor_assist) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_extract_transaction_nesting_depth) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_nontransactional_store_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_transaction_abort) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_transaction_begin) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_transaction_begin_constrained) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s370_transaction_end) (BYTE inst[], REGS *regs);
># 42 "cpu.c" 2
># 1 "inline.h" 1
># 16 "inline.h"
>static inline U16 s370_translate_asn (U16 asn, REGS *regs,
>        U32 *asteo, U32 aste[]);
>static inline int s370_authorize_asn (U16 ax, U32 aste[],
>        int atemask, REGS *regs);
>
>
>
>
>
>
>
>static inline int s370_translate_addr (U32 vaddr, int arn,
>        REGS *regs, int acctype);
>static inline void s370_purge_tlb_all ();
>static inline void s370_purge_tlb (REGS *regs);
>static inline void s370_purge_tlbe_all (U64 pfra);
>static inline void s370_purge_tlbe (REGS *regs, U64 pfra);
>static inline void s370_invalidate_tlb (REGS *regs, BYTE mask);
>
>
>
>static inline void s370_invalidate_tlbe (REGS *regs, BYTE *main);
>static inline void s370_invalidate_pte (BYTE ibyte, U64 op1,
>        U32 op2, REGS *regs);
>static inline BYTE *s370_logical_to_main (U32 addr, int arn,
>        REGS *regs, int acctype, BYTE akey);
>
>
>static inline BYTE *s390_logical_to_main (U32 addr, int arn, REGS *regs,
>        int acctype, BYTE akey);
>static inline int s390_translate_addr (U32 vaddr, int arn, REGS *regs,
>        int acctype);
>
>
>
>static inline BYTE *z900_logical_to_main (U64 addr, int arn, REGS *regs,
>        int acctype, BYTE akey);
>static inline int z900_translate_addr (U64 vaddr, int arn, REGS *regs,
>        int acctype);
>
>
>static inline void s370_vstorec (void *src, BYTE len,
>        U32 addr, int arn, REGS *regs);
>static inline void s370_vstoreb (BYTE value, U32 addr,
>        int arn, REGS *regs);
>static inline void s370_vstore2 (U16 value, U32 addr, int arn,
>        REGS *regs);
>static inline void s370_vstore4 (U32 value, U32 addr, int arn,
>        REGS *regs);
>static inline void s370_vstore8 (U64 value, U32 addr, int arn,
>        REGS *regs);
>static inline void s370_vfetchc (void *dest, BYTE len,
>        U32 addr, int arn, REGS *regs);
>static inline BYTE s370_vfetchb (U32 addr, int arn,
>        REGS *regs);
>static inline U16 s370_vfetch2 (U32 addr, int arn,
>        REGS *regs);
>static inline U32 s370_vfetch4 (U32 addr, int arn,
>        REGS *regs);
>static inline U64 s370_vfetch8 (U32 addr, int arn,
>        REGS *regs);
>static inline void s370_move_chars (U32 addr1, int arn1,
>      BYTE key1, U32 addr2, int arn2, BYTE key2, int len, REGS *regs);
>static inline void s370_validate_operand (U32 addr, int arn,
>        int len, int acctype, REGS *regs);
>static inline BYTE * s370_instfetch (REGS *regs, int exec);
>
>
>static inline BYTE * s370_instfetch (REGS *regs, int exec);
>
>
>
>static inline BYTE * s390_instfetch (REGS *regs, int exec);
># 100 "inline.h"
>static inline int add_logical(U32 *result, U32 op1, U32 op2)
>{
>    *result = op1 + op2;
>    return (*result == 0 ? 0 : 1) | (op1 > *result ? 2 : 0);
>}
>
>
>
>
>
>
>static inline int sub_logical(U32 *result, U32 op1, U32 op2)
>{
>    *result = op1 - op2;
>    return (*result == 0 ? 0 : 1) | (op1 < *result ? 0 : 2);
>}
>
>
>
>
>
>
>static inline int add_signed(U32 *result, U32 op1, U32 op2)
>{
>    *result = (S32)op1 + (S32)op2;
>
>    return ((S32)*result > 0) ?
>                ((S32)op1 < 0 && (S32)op2 < 0) ? 3 : 2 :
>            ((S32)*result < 0) ?
>                ((S32)op1 >= 0 && (S32)op2 >= 0) ? 3 : 1 :
>                ((S32)op1 < 0 && (S32)op2 < 0) ? 3 : 0;
>
>
>
>
>
>}
>
>
>
>
>
>
>static inline int sub_signed(U32 *result, U32 op1, U32 op2)
>{
>    *result = (S32)op1 - (S32)op2;
>
>    return ((S32)*result > 0) ?
>                ((S32)op1 < 0 && (S32)op2 >= 0) ? 3 : 2 :
>            ((S32)*result < 0) ?
>                ((S32)op1 >= 0 && (S32)op2 < 0) ? 3 : 1 :
>            ((S32)op1 < 0 && (S32)op2 >= 0) ? 3 : 0;
>
>
>
>
>
>}
>
>
>
>
>
>static inline void mul_signed ( U32 *resulthi, U32 *resultlo,
>                             U32 op1, U32 op2 )
>{
>S64 r;
>
>    r = (S64)(S32)op1 * (S32)op2;
>    *resulthi = (U32)((U64)r >> 32);
>    *resultlo = (U32)((U64)r & 0xFFFFFFFF);
>}
>
>
>
>
>
>
>
>static inline int div_signed ( U32 *remainder, U32 *quotient,
>              U32 dividendhi, U32 dividendlo, U32 divisor )
>{
>U64 dividend;
>S64 quot, rem;
>
>    if (divisor == 0) return 1;
>    dividend = (U64)dividendhi << 32 | dividendlo;
>    quot = (S64)dividend / (S32)divisor;
>    rem = (S64)dividend % (S32)divisor;
>    if (quot < -2147483648LL || quot > 2147483647LL) return 1;
>    *quotient = (U32)quot;
>    *remainder = (U32)rem;
>    return 0;
>}
># 203 "inline.h"
>static inline int add_logical_long(U64 *result, U64 op1, U64 op2)
>{
>    *result = op1 + op2;
>    return (*result == 0 ? 0 : 1) | (op1 > *result ? 2 : 0);
>}
>
>
>
>
>
>
>static inline int sub_logical_long(U64 *result, U64 op1, U64 op2)
>{
>    *result = op1 - op2;
>    return (*result == 0 ? 0 : 1) | (op1 < *result ? 0 : 2);
>}
>
>
>
>
>
>
>static inline int add_signed_long(U64 *result, U64 op1, U64 op2)
>{
>    *result = (S64)op1 + (S64)op2;
>
>    return (((S64)op1 < 0 && (S64)op2 < 0 && (S64)*result >= 0)
>      || ((S64)op1 >= 0 && (S64)op2 >= 0 && (S64)*result < 0)) ? 3 :
>                                              (S64)*result < 0 ? 1 :
>                                              (S64)*result > 0 ? 2 : 0;
>}
>
>
>
>
>
>
>static inline int sub_signed_long(U64 *result, U64 op1, U64 op2)
>{
>    *result = (S64)op1 - (S64)op2;
>
>    return (((S64)op1 < 0 && (S64)op2 >= 0 && (S64)*result >= 0)
>      || ((S64)op1 >= 0 && (S64)op2 < 0 && (S64)*result < 0)) ? 3 :
>                                             (S64)*result < 0 ? 1 :
>                                             (S64)*result > 0 ? 2 : 0;
>}
>
>
>
>
>
>
>
>static inline int div_logical_long
>                  (U64 *rem, U64 *quot, U64 high, U64 lo, U64 d)
>{
>    int i;
>
>    *quot = 0;
>    if (high >= d) return 1;
>    for (i = 0; i < 64; i++)
>    {
>    int ovf;
>        ovf = high >> 63;
>        high = (high << 1) | (lo >> 63);
>        lo <<= 1;
>        *quot <<= 1;
>        if (high >= d || ovf)
>        {
>            *quot += 1;
>            high -= d;
>        }
>    }
>    *rem = high;
>    return 0;
>}
>
>
>
>
>
>static inline int mult_logical_long
>                  (U64 *high, U64 *lo, U64 md, U64 mr)
>{
>    int i;
>
>    *high = 0; *lo = 0;
>    for (i = 0; i < 64; i++)
>    {
>    U64 ovf;
>        ovf = *high;
>        if (md & 1)
>            *high += mr;
>        md >>= 1;
>        *lo = (*lo >> 1) | (*high << 63);
>        if(ovf > *high)
>            *high = (*high >> 1) | 0x8000000000000000ULL;
>        else
>            *high >>= 1;
>    }
>    return 0;
>}
># 323 "inline.h"
>static inline int s370_is_fetch_protected (U32 addr, BYTE skey,
>                    BYTE akey, REGS *regs)
>{
>    ((addr)=(addr));
>    ((regs)=(regs));
>
>
>
>
>
>    if (__builtin_expect((akey == 0 || akey == (skey & 0xF0) || !(skey & 0x08)),1)
>
>                               )
>    return 0;
># 357 "inline.h"
>    return 1;
>
>}
># 371 "inline.h"
>static inline int s370_is_low_address_protected (U32 addr,
>                                              REGS *regs)
>{
>
>
>
>
>
>
>
>    if (addr > 511)
>
>        return 0;
>
>
>
>    if ((regs->cr[(0)].F.L.F & 0x10000000) == 0)
>        return 0;
>
>
>
>
>    if (regs->sie_active)
>        return 0;
>
>
>
>
>    if (regs->dat.private)
>        return 0;
>
>
>    return 1;
>
>}
># 421 "inline.h"
>static inline int s370_is_store_protected (U32 addr, BYTE skey,
>               BYTE akey, REGS *regs)
>{
>
>
>
>
>    if (s370_is_low_address_protected (addr, regs))
>        return 1;
>
>
>
>
>    if (regs->dat.protect)
>        return 1;
>
>    if(__builtin_expect(((regs)->sie_mode),0) && regs->hostregs->dat.protect)
>        return 1;
>
>
>
>
>    if (akey == 0)
>        return 0;
># 457 "inline.h"
>    if (akey != (skey & 0xF0))
>        return 1;
>
>
>    return 0;
>
>}
># 475 "inline.h"
>static inline BYTE *s370_fetch_main_absolute (U64 addr,
>                                REGS *regs)
>
>{
>
>
>
>
>
>    do { if(__builtin_expect((((regs))->sie_mode),0) && !(regs)->sie_pref) *(&addr) = ( s390_logical_to_main(((regs)->sie_mso + *(&addr)), (18), ((regs)->hostregs), ((0x0004)), (0)), ((regs)->hostregs)->dat.aaddr ); } while(0);
>
>
>    (regs)->storkeys[(addr)>>11] |= 0x04;
>
>
>    return (regs->mainstor + addr);
>
>}
># 503 "inline.h"
>static inline U64 s370_fetch_doubleword_absolute (U64 addr,
>                                REGS *regs)
>{
>
>
>
>
>
>
>    return __bswap_64 (*(U64 *)s370_fetch_main_absolute((addr), (regs)));
>
>
>
>}
># 527 "inline.h"
>static inline U32 s370_fetch_fullword_absolute (U64 addr,
>                                REGS *regs)
>{
>    return __bswap_32 (fetch_fw_noswap((s370_fetch_main_absolute((addr), (regs)))));
>}
># 542 "inline.h"
>static inline U16 s370_fetch_halfword_absolute (U64 addr,
>                                REGS *regs)
>{
>    return (__extension__ ({ unsigned short int __v, __x = (unsigned short int) (fetch_hw_noswap((s370_fetch_main_absolute((addr), (regs))))); if (__builtin_constant_p (__x)) __v = ((unsigned short int) ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8))); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; }));
>}
># 555 "inline.h"
>static inline void s370_store_doubleword_absolute (U64 value,
>                          U64 addr, REGS *regs)
>{
>
>
>
>
>
>    do { if(__builtin_expect((((regs))->sie_mode),0) && !(regs)->sie_pref) *(&addr) = ( s390_logical_to_main(((regs)->sie_mso + *(&addr)), (18), ((regs)->hostregs), ((0x0002)), (0)), ((regs)->hostregs)->dat.aaddr ); } while(0);
>
>
>    (regs)->storkeys[(addr)>>11] |= (0x04 | 0x02);
>
>
>    store_dw_i686_noswap((regs->mainstor + addr),__bswap_64 ((value)));
>
>}
># 580 "inline.h"
>static inline void s370_store_fullword_absolute (U32 value,
>                          U64 addr, REGS *regs)
>{
>
>
>
>
>
>    do { if(__builtin_expect((((regs))->sie_mode),0) && !(regs)->sie_pref) *(&addr) = ( s390_logical_to_main(((regs)->sie_mso + *(&addr)), (18), ((regs)->hostregs), ((0x0002)), (0)), ((regs)->hostregs)->dat.aaddr ); } while(0);
>
>
>    (regs)->storkeys[(addr)>>11] |= (0x04 | 0x02);
>
>
>    store_fw_noswap((regs->mainstor + addr), __bswap_32 ((value)));
>
>}
># 637 "inline.h"
>static inline U64 s370_subspace_replace (U64 std, U32 asteo,
>                        U16 *xcode, REGS *regs)
>{
>U32 ducto;
>U32 duct0;
>U32 duct1;
>U32 duct3;
>U32 ssasteo;
>U32 ssaste[16];
>BYTE *p;
>
>
>    if (xcode != ((void *)0)) *xcode = 0;
>
>
>
>
>    if (!0
>        || (std & 0x00000200) == 0)
>        return std;
>
>
>    ducto = regs->cr[(2)].F.L.F & 0x7FFFFFC0;
>    ducto = ( ((U32)(ducto) & 0x7FFFF000) == 0 || ((U32)(ducto) & 0x7FFFF000) == (regs->px.F.L.F) ? (U32)(ducto) ^ (regs->px.F.L.F) : (ducto) );
>
>
>    if (ducto > regs->mainlim)
>        regs->program_interrupt (regs, 0x0005);
>
>
>
>    p = s370_fetch_main_absolute((ducto), (regs));
>    duct0 = __bswap_32 (fetch_fw_noswap((p)));
>    duct1 = __bswap_32 (fetch_fw_noswap((p+4)));
>    duct3 = __bswap_32 (fetch_fw_noswap((p+12)));
>
>
>
>
>    if ((duct1 & 0x80000000) == 0
>        || asteo != (duct0 & 0x7FFFFFC0))
>        return std;
>
>
>    ssasteo = duct1 & 0x7FFFFFC0;
>    ssasteo = ( ((U32)(ssasteo) & 0x7FFFF000) == 0 || ((U32)(ssasteo) & 0x7FFFF000) == (regs->px.F.L.F) ? (U32)(ssasteo) ^ (regs->px.F.L.F) : (ssasteo) );
>
>
>    if (ssasteo > regs->mainlim)
>        regs->program_interrupt (regs, 0x0005);
>
>
>
>    p = s370_fetch_main_absolute((ssasteo), (regs));
>    ssaste[0] = __bswap_32 (fetch_fw_noswap((p)));
>    ssaste[2] = __bswap_32 (fetch_fw_noswap((p+8)));
>
>
>
>    ssaste[5] = __bswap_32 (fetch_fw_noswap((p+20)));
>
>
>    if (ssaste[0] & 0x80000000)
>    {
>        regs->excarid = 0;
>        if (xcode == ((void *)0))
>            regs->program_interrupt (regs, 0x002B);
>        else
>            *xcode = 0x002B;
>        return 0;
>    }
>
>
>
>    if ((ssaste[5] & 0xFFFFFFFF) != (duct3 & 0xFFFFFFFF))
>    {
>        regs->excarid = 0;
>        if (xcode == ((void *)0))
>            regs->program_interrupt (regs, 0x002C);
>        else
>            *xcode = 0x002C;
>        return 0;
>    }
>
>
>
>
>    std &= (0x80000000 | 0x00000080);
>    std |= (((ssaste)[2])
>                & ~((U64)(0x80000000 | 0x00000080)));
>
>
>    return std;
>
>}
>
>
># 1 "dat.h" 1
># 53 "dat.h"
>static inline U16 s370_translate_asn (U16 asn, REGS *regs,
>                                                U32 *asteo, U32 aste[])
>{
>U32 afte_addr;
>U32 afte;
>U32 aste_addr;
>BYTE *aste_main;
>int code;
>int numwords;
>int i;
>
>
>    afte_addr = (regs->cr[(14)].F.L.F & 0x0007FFFF) << 12;
>    afte_addr += (asn & 0xFFC0) >> 4;
>
>
>    if (afte_addr > regs->mainlim)
>        goto asn_addr_excp;
>
>
>
>    afte_addr = ( ((U32)(afte_addr) & 0x7FFFF000) == 0 || ((U32)(afte_addr) & 0x7FFFF000) == (regs->px.F.L.F) ? (U32)(afte_addr) ^ (regs->px.F.L.F) : (afte_addr) );
>    afte = s370_fetch_fullword_absolute (afte_addr, regs);
>
>
>    if (afte & 0x80000000)
>        goto asn_afx_tran_excp;
>
>
>
>    if (!0) {
>        if (afte & 0x0000000F)
>              goto asn_asn_tran_spec_excp;
>    } else {
>        if (afte & 0x0000003F)
>              goto asn_asn_tran_spec_excp;
>    }
>
>
>
>    if (!0) {
>        aste_addr = afte & 0x7FFFFFF0;
>        aste_addr += (asn & 0x003F) << 4;
>        numwords = 4;
>    } else {
>        aste_addr = afte & 0x7FFFFFC0;
>        aste_addr += (asn & 0x003F) << 6;
>        numwords = 16;
>    }
>
>
>    aste_addr &= 0x7FFFFFFF;
>
>
>    if (aste_addr > regs->mainlim)
>        goto asn_addr_excp;
>
>
>    *asteo = aste_addr;
>
>
>
>
>    aste_addr = ( ((U32)(aste_addr) & 0x7FFFF000) == 0 || ((U32)(aste_addr) & 0x7FFFF000) == (regs->px.F.L.F) ? (U32)(aste_addr) ^ (regs->px.F.L.F) : (aste_addr) );
>    aste_main = s370_fetch_main_absolute((aste_addr), (regs));
>    for (i = 0; i < numwords; i++)
>    {
>        aste[i] = __bswap_32 (fetch_fw_noswap((aste_main)));
>        aste_main += 4;
>    }
>
>    while (i < 16) aste[i++] = 0;
>
>
>
>    if (aste[0] & 0x80000000)
>        goto asn_asx_tran_excp;
>
>
>
>    if ((aste[0] & 0x00000002) || (aste[1] & 0x0000000F)
>        || ((aste[0] & 0x00000001)
>
>
>
>            ))
>        goto asn_asn_tran_spec_excp;
>
>
>    return 0;
>
>
>asn_addr_excp:
>    code = 0x0005;
>    goto asn_prog_check;
>
>
>asn_asn_tran_spec_excp:
>    code = 0x0017;
>    goto asn_prog_check;
>
>
>asn_prog_check:
>    regs->program_interrupt (regs, code);
>
>
>asn_afx_tran_excp:
>    regs->ea.F.L.F = asn;
>    code = 0x0020;
>    return code;
>
>asn_asx_tran_excp:
>    regs->ea.F.L.F = asn;
>    code = 0x0021;
>    return code;
>
>}
># 203 "dat.h"
>static inline int s370_authorize_asn (U16 ax, U32 aste[],
>                                               int atemask, REGS *regs)
>{
>U32 ato;
>int atl;
>BYTE ate;
>
>
>
>
>    ato = aste[0] & 0x7FFFFFFC;
>    atl = aste[1] & 0x0000FFF0;
>
>
>    if ((ax & 0xFFF0) > atl)
>        return 1;
>
>
>
>    ato += (ax >> 2);
>
>
>    ato &= 0x7FFFFFFF;
>
>
>    if (ato > regs->mainlim)
>        goto auth_addr_excp;
>
>
>
>    ato = ( ((U32)(ato) & 0x7FFFF000) == 0 || ((U32)(ato) & 0x7FFFF000) == (regs->px.F.L.F) ? (U32)(ato) ^ (regs->px.F.L.F) : (ato) );
>
>    do { if(__builtin_expect((((regs))->sie_mode),0) && !(regs)->sie_pref) *(&ato) = ( s390_logical_to_main(((regs)->sie_mso + *(&ato)), (18), ((regs)->hostregs), ((0)), (0)), ((regs)->hostregs)->dat.aaddr ); } while(0);
>
>    ate = regs->mainstor[ato];
>    ate <<= ((ax & 0x03)*2);
>
>
>    (regs)->storkeys[(ato)>>11] |= 0x04;
>
>
>
>    if ((ate & atemask) == 0)
>        return 1;
>
>
>    return 0;
>
>
>auth_addr_excp:
>    regs->program_interrupt (regs, 0x0005);
>    return 1;
>
>}
># 561 "dat.h"
>static inline U16 s370_load_address_space_designator (int arn,
>           REGS *regs, int acctype)
>{
>
>
>
>
>
>
>    ((acctype)=(acctype));
>
>
>    switch(arn) {
>
>    case 18:
>        regs->dat.stid = 0x000;
>        regs->dat.asd = regs->cr[(1)].F.L.F;
>        break;
>
>    case 17:
>        regs->dat.stid = 0x002;
>        regs->dat.asd = regs->cr[(7)].F.L.F;
>        break;
>
>    case 16:
>        regs->dat.stid = 0x003;
>        regs->dat.asd = regs->cr[(13)].F.L.F;
>        break;
>
>    case 19:
>        regs->dat.stid = 0;
>        regs->dat.asd = 0xFFFFFFFF;
>        break;
>
>    case 20:
>        switch(regs->aea_ar[20]) {
>
>        case 1:
>            regs->dat.stid = 0x000;
>            break;
>
>
>
>
>
>        default:
>            regs->dat.stid = 0;
>        }
>
>        regs->dat.asd = regs->cr[(regs->aea_ar[20])].F.L.F;
>        break;
>
>    default:
># 698 "dat.h"
>        if (((&regs->psw)->asc == 0x80))
>        {
>            regs->dat.stid = 0x002;
>            regs->dat.asd = regs->cr[(7)].F.L.F;
>            break;
>        }
># 716 "dat.h"
>        regs->dat.stid = 0x000;
>        regs->dat.asd = regs->cr[(1)].F.L.F;
>        break;
>
>    }
>
>    return 0;
>
>}
># 816 "dat.h"
>static inline int s370_translate_addr (U32 vaddr, int arn,
>                                            REGS *regs, int acctype)
>{
>U64 sto = 0;
>U64 pto = 0;
>int cc;
>int tlbix = (((U32)(vaddr) >> 11) & 0x3FF);
>
>
>
>
>
>U32 stl;
>U64 ste;
>U16 pte;
>U32 ptl;
>
>    regs->dat.private = regs->dat.protect = 0;
>
>
>    if (s370_load_address_space_designator (arn, regs, acctype))
>        goto tran_alet_excp;
>
>
>    if ((((regs->cr[(0)].F.L.F & 0x00C00000) != 0x00400000) &&
>       ((regs->cr[(0)].F.L.F & 0x00C00000) != 0x00800000)) ||
>       (((regs->cr[(0)].F.L.F & 0x00380000) != 0x00000000) &&
>       ((regs->cr[(0)].F.L.F & 0x00380000) != 0x00100000)))
>       goto tran_spec_excp;
>
>
>    if ( ((vaddr & 0x00E00000) | regs->tlbID) == regs->tlb.vaddr[(tlbix)].F.L.F
>        && (regs->tlb.common[tlbix] || regs->dat.asd == regs->tlb.asd[(tlbix)].F.L.F)
>        && !(regs->tlb.common[tlbix] && regs->dat.private)
>        && !(acctype & 0x0100) )
>    {
>        pte = regs->tlb.pte[(tlbix)].F.L.F;
>
>
>
>        if (regs->tlb.protect[tlbix])
>            regs->dat.protect = regs->tlb.protect[tlbix];
>
>    }
>    else
>    {
>
>
>
>        sto = regs->dat.asd & 0x00FFFFC0;
>        stl = regs->dat.asd & 0xFF000000;
>        sto += ((regs->cr[(0)].F.L.F & 0x00380000) == 0x00100000) ?
>            ((vaddr & 0x00F00000) >> 18) :
>            ((vaddr & 0x00FF0000) >> 14);
>
>
>        if (((regs->cr[(0)].F.L.F & 0x00380000) == 0x00000000) &&
>            ((vaddr << 4) & 0xFF000000) > stl)
>            goto seg_tran_length;
>
>
>        if (sto > regs->mainlim)
>            goto address_excp;
>
>
>
>        sto = ( ((U32)(sto) & 0x7FFFF000) == 0 || ((U32)(sto) & 0x7FFFF000) == (regs->px.F.L.F) ? (U32)(sto) ^ (regs->px.F.L.F) : (sto) );
>        ste = s370_fetch_fullword_absolute (sto, regs);
>
>
>        if (ste & 0x00000001)
>            goto seg_tran_invalid;
>
>
>        if (ste & 0x0F000000)
>            goto tran_spec_excp;
>
>
>        pto = ste & 0x00FFFFF8;
>        ptl = ste & 0xF0000000;
>
>
>
>
>        pto += ((regs->cr[(0)].F.L.F & 0x00380000) == 0x00100000) ?
>            (((regs->cr[(0)].F.L.F & 0x00C00000) == 0x00800000) ?
>            ((vaddr & 0x000FF000) >> 11) :
>            ((vaddr & 0x000FF800) >> 10)) :
>            (((regs->cr[(0)].F.L.F & 0x00C00000) == 0x00800000) ?
>            ((vaddr & 0x0000F000) >> 11) :
>            ((vaddr & 0x0000F800) >> 10));
>
>
>        if (pto > regs->mainlim)
>            goto address_excp;
>
>
>        if ((((regs->cr[(0)].F.L.F & 0x00380000) == 0x00100000) &&
>            (((vaddr & 0x000F0000) >> 16) > ptl)) ||
>            (((regs->cr[(0)].F.L.F & 0x00380000) == 0x00000000) &&
>            (((vaddr & 0x0000F000) >> 12) > ptl)))
>            goto page_tran_length;
>
>
>
>        pto = ( ((U32)(pto) & 0x7FFFF000) == 0 || ((U32)(pto) & 0x7FFFF000) == (regs->px.F.L.F) ? (U32)(pto) ^ (regs->px.F.L.F) : (pto) );
>        pte = s370_fetch_halfword_absolute (pto, regs);
>
>
>        if ((((regs->cr[(0)].F.L.F & 0x00C00000) == 0x00800000) &&
>            (pte & 0x0008)) ||
>            (((regs->cr[(0)].F.L.F & 0x00C00000) == 0x00400000) &&
>            (pte & 0x0004)))
>            goto page_tran_invalid;
>
>
>        if (((regs->cr[(0)].F.L.F & 0x00C00000) == 0x00400000) &&
>            (pte & 0x0002))
>            goto tran_spec_excp;
>
>
>
>        if (ste & 0x00000004)
>            regs->dat.protect |= 1;
>
>
>
>        if (!(acctype & 0x0100))
>        {
>            regs->tlb.asd[(tlbix)].F.L.F = regs->dat.asd;
>            regs->tlb.vaddr[(tlbix)].F.L.F = (vaddr & 0x00E00000) | regs->tlbID;
>            regs->tlb.pte[(tlbix)].F.L.F = pte;
>            regs->tlb.common[tlbix] = (ste & 0x00000002) ? 1 : 0;
>            regs->tlb.protect[tlbix] = regs->dat.protect;
>            regs->tlb.acc[tlbix] = 0;
>            regs->tlb.main[tlbix] = ((void *)0);
>
>
>            if ((regs->cr[(0)].F.L.F & 0x00C00000) == 0x00800000)
>            {
>                regs->tlb.asd[(tlbix^1)].F.L.F = regs->tlb.asd[(tlbix)].F.L.F;
>                regs->tlb.vaddr[(tlbix^1)].F.L.F = (vaddr & 0x00E00000) | regs->tlbID;
>                regs->tlb.pte[(tlbix^1)].F.L.F = regs->tlb.pte[(tlbix)].F.L.F;
>                regs->tlb.common[tlbix^1] = regs->tlb.common[tlbix];
>                regs->tlb.protect[tlbix^1] = regs->tlb.protect[tlbix];
>                regs->tlb.acc[tlbix^1] = 0;
>                regs->tlb.main[tlbix^1] = ((void *)0);
>            }
>        }
>    }
>
>
>
>    regs->dat.raddr = ((regs->cr[(0)].F.L.F & 0x00C00000) == 0x00800000) ?
>
>        (((U32)pte & 0x0006) << 23) |
>
>        (((U32)pte & 0xFFF0) << 8) | (vaddr & 0xFFF) :
>        (((U32)pte & 0xFFF8) << 8) | (vaddr & 0x7FF);
>
>    regs->dat.rpfra = regs->dat.raddr & 0x7FFFF800;
># 1568 "dat.h"
>    regs->dat.xcode = 0;
>    return 0;
>
>
>
>address_excp:
>
>
>    regs->dat.xcode = 0x0005;
>    goto tran_prog_check;
>
>tran_spec_excp:
># 1589 "dat.h"
>    regs->dat.xcode = 0x0012;
>    goto tran_prog_check;
>
>
>
>
>
>
>
>tran_prog_check:
># 1607 "dat.h"
>    regs->program_interrupt (regs, regs->dat.xcode);
>
>
>seg_tran_invalid:
>
>    if (acctype & 0x0400)
>    {
>        regs->dat.raddr = sto;
>        cc = 2;
>        return cc;
>    }
>
>
>    regs->dat.xcode = 0x0010;
>    regs->dat.raddr = sto;
>    cc = 1;
>    goto tran_excp_addr;
>
>page_tran_invalid:
>    regs->dat.xcode = 0x0011;
>    regs->dat.raddr = pto;
>    if(acctype & 0x0200) return 0;
>    cc = 2;
>    goto tran_excp_addr;
>
>
>page_tran_length:
>    regs->dat.xcode = 0x0011;
>    regs->dat.raddr = pto;
>    cc = 3;
>    goto tran_excp_addr;
>
>
>seg_tran_length:
>
>
>    regs->dat.xcode = 0x0010;
>    regs->dat.raddr = sto;
>    cc = 3;
>    goto tran_excp_addr;
>
>tran_alet_excp:
>    regs->excarid = arn;
>    cc = (acctype & 0x0400) ? 3 : 4;
>    return cc;
># 1713 "dat.h"
>tran_excp_addr:
>
>    if (acctype & 0x0400)
>        return 3;
>
>
>    regs->ea.F.L.F = vaddr & 0x7FFFF800;
># 1737 "dat.h"
>    if(regs->dat.stid == 0x001)
>    {
>        if ((regs->dat.asd & 0x7FFFF000) == (regs->cr[(1)].F.L.F & 0x7FFFF000))
>            regs->ea.F.L.F |= 0x000;
>        else if ((regs->dat.asd & 0x7FFFF000) == (regs->cr[(7)].F.L.F & 0x7FFFF000))
>            regs->ea.F.L.F |= 0x002;
>        else if ((regs->dat.asd & 0x7FFFF000) == (regs->cr[(13)].F.L.F & 0x7FFFF000))
>            regs->ea.F.L.F |= 0x003;
>        else
>            regs->ea.F.L.F |= 0x001;
>    }
>    else
>        if((regs->dat.stid == 0x002)
>          && (((&regs->psw)->asc == 0x00)
>            || ((&regs->psw)->asc == 0x80)))
>            regs->ea.F.L.F |= 0x002 | 0x80000000;
>        else
>            regs->ea.F.L.F |= regs->dat.stid;
># 1767 "dat.h"
>    if (((&regs->psw)->asc == 0x40)
>     || ((0) && ( ((((regs->guestregs))->siebk->mx) & (0x01)) && (((&(regs->guestregs)->psw)->asc & ( 1 << (6) )) != 0) ))
>       )
>       regs->excarid = arn > 15 ? 0 : arn;
>
>
>    return cc;
>
>}
>
>
>
>
>
>static inline void s370_purge_tlb (REGS *regs)
>{
>    do { if ((regs)->aie) { (regs)->psw.ia.F.L.F = ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((0))) & (0x00FFFFFF)); (regs)->aie = ((void *)0); } } while (0);
>    if (((++regs->tlbID) & 0x001FFFFF) == 0)
>    {
>        memset (&regs->tlb.vaddr, 0, 1024 * sizeof(DW));
>        regs->tlbID = 1;
>    }
>
>
>    if(regs->host && regs->guestregs)
>    {
>        do { if ((regs->guestregs)->aie) { (regs->guestregs)->psw.ia.F.L.F = ((U32)((((regs->guestregs)))->aiv.F.L.F + ((intptr_t)(((regs->guestregs)))->ip - (intptr_t)(((regs->guestregs)))->aip) + ((0))) & (0x00FFFFFF)); (regs->guestregs)->aie = ((void *)0); } } while (0);
>        if (((++regs->guestregs->tlbID) & 0x001FFFFF) == 0)
>        {
>            memset (&regs->guestregs->tlb.vaddr, 0, 1024 * sizeof(DW));
>            regs->guestregs->tlbID = 1;
>        }
>    }
>
>}
>
>
>
>
>
>static inline void s370_purge_tlb_all ()
>{
>int i;
>
>    for (i = 0; i < sysblk.maxcpu; i++)
>        if ((sysblk.regs[(i)] != ((void *)0))
>         && (sysblk.regs[i]->cpubit & sysblk.started_mask))
>            s370_purge_tlb (sysblk.regs[i]);
>
>}
>
>
>
>
>
>static inline void s370_purge_tlbe (REGS *regs, U64 pfra)
>{
>int i;
>U64 pte;
>U64 ptemask;
>
>
>    ptemask = ((regs->cr[(0)].F.L.F & 0x00C00000) == 0x00800000) ?
>              0xFFF0 : 0xFFF8;
>    pte = ((pfra & 0xFFFFFF) >> 8) & ptemask;
># 1844 "dat.h"
>    do { if ((regs)->aie) { (regs)->psw.ia.F.L.F = ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((0))) & (0x00FFFFFF)); (regs)->aie = ((void *)0); } } while (0);
>    for (i = 0; i < 1024; i++)
>        if ((regs->tlb.pte[(i)].F.L.F & ptemask) == pte)
>            regs->tlb.vaddr[(i)].F.L.F &= 0x00E00000;
>
>
>
>    if (regs->host && regs->guestregs)
>    {
>        do { if ((regs->guestregs)->aie) { (regs->guestregs)->psw.ia.F.L.F = ((U32)((((regs->guestregs)))->aiv.F.L.F + ((intptr_t)(((regs->guestregs)))->ip - (intptr_t)(((regs->guestregs)))->aip) + ((0))) & (0x00FFFFFF)); (regs->guestregs)->aie = ((void *)0); } } while (0);
>        for (i = 0; i < 1024; i++)
>            if ((regs->guestregs->tlb.pte[(i)].F.L.F & ptemask) == pte)
>                regs->guestregs->tlb.vaddr[(i)].F.L.F &= 0x00E00000;
>    }
>    else
>
>    if (regs->guest)
>    {
>        do { if ((regs->hostregs)->aie) { (regs->hostregs)->psw.ia.F.L.F = ((U32)((((regs->hostregs)))->aiv.F.L.F + ((intptr_t)(((regs->hostregs)))->ip - (intptr_t)(((regs->hostregs)))->aip) + ((0))) & (0x00FFFFFF)); (regs->hostregs)->aie = ((void *)0); } } while (0);
>        for (i = 0; i < 1024; i++)
>            if ((regs->hostregs->tlb.pte[(i)].F.L.F & ptemask) == pte)
>                regs->hostregs->tlb.vaddr[(i)].F.L.F &= 0x00E00000;
>    }
>
>
>}
>
>
>
>
>
>static inline void s370_purge_tlbe_all (U64 pfra)
>{
>int i;
>
>    for (i = 0; i < sysblk.maxcpu; i++)
>        if ((sysblk.regs[(i)] != ((void *)0))
>         && (sysblk.regs[i]->cpubit & sysblk.started_mask))
>            s370_purge_tlbe (sysblk.regs[i], pfra);
>
>}
>
>
>
>
>
>static inline void s370_invalidate_tlb (REGS *regs, BYTE mask)
>{
>int i;
>
>    do { if ((regs)->aie) { (regs)->psw.ia.F.L.F = ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((0))) & (0x00FFFFFF)); (regs)->aie = ((void *)0); } } while (0);
>    if (mask == 0)
>        memset(&regs->tlb.acc, 0, 1024);
>    else
>        for (i = 0; i < 1024; i++)
>            if ((regs->tlb.vaddr[(i)].F.L.F & 0x001FFFFF) == regs->tlbID)
>                regs->tlb.acc[i] &= mask;
>
>
>
>    if(regs->host && regs->guestregs)
>    {
>        do { if ((regs->guestregs)->aie) { (regs->guestregs)->psw.ia.F.L.F = ((U32)((((regs->guestregs)))->aiv.F.L.F + ((intptr_t)(((regs->guestregs)))->ip - (intptr_t)(((regs->guestregs)))->aip) + ((0))) & (0x00FFFFFF)); (regs->guestregs)->aie = ((void *)0); } } while (0);
>        if (mask == 0)
>            memset(&regs->guestregs->tlb.acc, 0, 1024);
>        else
>            for (i = 0; i < 1024; i++)
>                if ((regs->guestregs->tlb.vaddr[(i)].F.L.F & 0x001FFFFF) == regs->guestregs->tlbID)
>                    regs->guestregs->tlb.acc[i] &= mask;
>    }
>    else
>
>    if(regs->guest)
>    {
>        do { if ((regs->hostregs)->aie) { (regs->hostregs)->psw.ia.F.L.F = ((U32)((((regs->hostregs)))->aiv.F.L.F + ((intptr_t)(((regs->hostregs)))->ip - (intptr_t)(((regs->hostregs)))->aip) + ((0))) & (0x00FFFFFF)); (regs->hostregs)->aie = ((void *)0); } } while (0);
>        if (mask == 0)
>            memset(&regs->hostregs->tlb.acc, 0, 1024);
>        else
>            for (i = 0; i < 1024; i++)
>                if ((regs->hostregs->tlb.vaddr[(i)].F.L.F & 0x001FFFFF) == regs->hostregs->tlbID)
>                    regs->hostregs->tlb.acc[i] &= mask;
>    }
>
>
>}
># 1951 "dat.h"
>static inline void s370_invalidate_tlbe (REGS *regs, BYTE *main)
>{
>    int i;
>    int shift;
>    BYTE *mainwid;
>
>    if (main == ((void *)0))
>    {
>        s370_invalidate_tlb(regs, 0);
>        return;
>    }
>
>    mainwid = main + regs->tlbID;
>
>    do { if ((main) == (regs)->aip && (regs)->aie) { (regs)->psw.ia.F.L.F = ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((0))) & (0x00FFFFFF)); (regs)->aie = ((void *)0); } } while (0);
>    shift = regs->arch_mode == 0 ? 11 : 12;
>    for (i = 0; i < 1024; i++)
>        if ((BYTE*)((uintptr_t)(regs->tlb.main[i]) ^ (uintptr_t)((regs->tlb.vaddr[(i)].F.L.F | (i << shift))))
>
>                     == mainwid)
>        {
>            regs->tlb.acc[i] = 0;
>
>            if ((regs->cr[(0)].F.L.F & 0x00C00000) == 0x00800000)
>                regs->tlb.acc[i^1] = 0;
>
>        }
>
>
>
>    if (regs->host && regs->guestregs)
>    {
>        do { if ((main) == (regs->guestregs)->aip && (regs->guestregs)->aie) { (regs->guestregs)->psw.ia.F.L.F = ((U32)((((regs->guestregs)))->aiv.F.L.F + ((intptr_t)(((regs->guestregs)))->ip - (intptr_t)(((regs->guestregs)))->aip) + ((0))) & (0x00FFFFFF)); (regs->guestregs)->aie = ((void *)0); } } while (0);
>        shift = regs->guestregs->arch_mode == 0 ? 11 : 12;
>        for (i = 0; i < 1024; i++)
>            if ((BYTE*)((uintptr_t)(regs->guestregs->tlb.main[i]) ^ (uintptr_t)((regs->guestregs->tlb.vaddr[(i)].F.L.F | (i << shift))))
>
>                         == mainwid)
>            {
>                regs->guestregs->tlb.acc[i] = 0;
>
>                if ((regs->guestregs->cr[(0)].F.L.F & 0x00C00000) == 0x00800000)
>                    regs->guestregs->tlb.acc[i^1] = 0;
>
>            }
>    }
>
>
>    if (regs->guest)
>    {
>        do { if ((main) == (regs->hostregs)->aip && (regs->hostregs)->aie) { (regs->hostregs)->psw.ia.F.L.F = ((U32)((((regs->hostregs)))->aiv.F.L.F + ((intptr_t)(((regs->hostregs)))->ip - (intptr_t)(((regs->hostregs)))->aip) + ((0))) & (0x00FFFFFF)); (regs->hostregs)->aie = ((void *)0); } } while (0);
>        shift = regs->hostregs->arch_mode == 0 ? 11 : 12;
>        for (i = 0; i < 1024; i++)
>            if ((BYTE*)((uintptr_t)(regs->hostregs->tlb.main[i]) ^ (uintptr_t)((regs->hostregs->tlb.vaddr[(i)].F.L.F | (i << shift))))
>
>                         == mainwid)
>            {
>                regs->hostregs->tlb.acc[i] = 0;
>
>                if ((regs->hostregs->cr[(0)].F.L.F & 0x00C00000) == 0x00800000)
>                    regs->hostregs->tlb.acc[i^1] = 0;
>
>            }
>    }
>
>
>
>}
># 2041 "dat.h"
>static inline void s370_invalidate_pte (BYTE ibyte, U64 op1,
>                                                    U32 op2, REGS *regs)
>{
>U64 raddr;
>U64 pte;
>U64 pfra;
>
>    ((ibyte)=(ibyte));
>
>
>    {
>
>        if ((((regs->cr[(0)].F.L.F & 0x00C00000) != 0x00400000) &&
>           ((regs->cr[(0)].F.L.F & 0x00C00000) != 0x00800000)) ||
>           (((regs->cr[(0)].F.L.F & 0x00380000) != 0x00000000) &&
>           ((regs->cr[(0)].F.L.F & 0x00380000) != 0x00100000)))
>            regs->program_interrupt (regs,
>                              0x0012);
>
>
>
>
>        raddr = (op1 & 0x00FFFFF8)
>                    + (((regs->cr[(0)].F.L.F & 0x00380000) == 0x00100000) ?
>                      (((regs->cr[(0)].F.L.F & 0x00C00000) == 0x00800000) ?
>                      ((op2 & 0x000FF000) >> 11) :
>                      ((op2 & 0x000FF800) >> 10)) :
>                      (((regs->cr[(0)].F.L.F & 0x00C00000) == 0x00800000) ?
>                      ((op2 & 0x0000F000) >> 11) :
>                      ((op2 & 0x0000F800) >> 10)));
>        raddr &= 0x00FFFFFF;
>
>
>
>        pte = s370_vfetch2 ( raddr, 19, regs );
>
>
>
>
>
>
>        if ((regs->cr[(0)].F.L.F & 0x00C00000) == 0x00400000)
>            pte |= 0x0004;
>        else
>            pte |= 0x0008;
>        s370_vstore2 ( pte, raddr, 19, regs );
>        pfra = ((regs->cr[(0)].F.L.F & 0x00C00000) == 0x00800000) ?
>
>            (((U32)pte & 0x0006) << 23) |
>
>            (((U32)pte & 0xFFF0) << 8) :
>            (((U32)pte & 0xFFF8) << 8);
>    }
># 2153 "dat.h"
>    s370_purge_tlbe_all (pfra);
>
>}
># 2210 "dat.h"
>static inline BYTE *s370_logical_to_main_l (U32 addr, int arn,
>                                    REGS *regs, int acctype, BYTE akey,
>                                    size_t len)
>{
>U64 aaddr;
>U64 apfra;
>int ix = (((U32)(addr) >> 11) & 0x3FF);
>
>
>    if ( ((!(((&regs->psw)->states & ( 1 << (3) )) != 0) || ((&regs->psw)->sysmask & 0x04)==0) || arn == 19)
># 2232 "dat.h"
>       )
>    {
>        regs->dat.private = regs->dat.protect = 0;
>        regs->dat.raddr = addr;
>        regs->dat.rpfra = addr & 0x7FFFF800;
>
>
>        regs->tlb.asd[(ix)].F.L.F = 0xFFFFFFFF;
>        regs->tlb.vaddr[(ix)].F.L.F = (addr & 0x00E00000) | regs->tlbID;
>        regs->tlb.pte[(ix)].F.L.F = addr & 0x00E00000;
>        regs->tlb.acc[ix] =
>        regs->tlb.common[ix] =
>        regs->tlb.protect[ix] = 0;
>    }
>    else {
>        if (s370_translate_addr (addr, arn, regs, acctype))
>            goto vabs_prog_check;
>    }
>
>    if (regs->dat.protect
>     && (acctype & (0x0002|0x0001)))
>        goto vabs_prot_excp;
>
>
>    regs->dat.aaddr = aaddr = ( ((U32)(regs->dat.raddr) & 0x7FFFF000) == 0 || ((U32)(regs->dat.raddr) & 0x7FFFF000) == (regs->px.F.L.F) ? (U32)(regs->dat.raddr) ^ (regs->px.F.L.F) : (regs->dat.raddr) );
>    apfra=( ((U32)(regs->dat.rpfra) & 0x7FFFF000) == 0 || ((U32)(regs->dat.rpfra) & 0x7FFFF000) == (regs->px.F.L.F) ? (U32)(regs->dat.rpfra) ^ (regs->px.F.L.F) : (regs->dat.rpfra) );
>
>
>    if (regs->dat.aaddr > regs->mainlim)
>        goto vabs_addr_excp;
>
>
>    if(__builtin_expect(((regs)->sie_mode),0)) regs->hostregs->dat.protect = 0;
>    if(__builtin_expect(((regs)->sie_mode),0) && !regs->sie_pref)
>    {
>
>        if (s390_translate_addr((regs->sie_mso + regs->dat.aaddr), ((arn > 0 && arn < 16 && ( ((((regs))->siebk->mx) & (0x01)) && (((&(regs)->psw)->asc & ( 1 << (6) )) != 0) )) ? arn : 18), (regs->hostregs), (0))
>
>                                                )
>            (regs->hostregs->program_interrupt) (regs->hostregs, regs->hostregs->dat.xcode);
>
>        regs->dat.protect |= regs->hostregs->dat.protect;
>        regs->tlb.protect[ix] |= regs->hostregs->dat.protect;
>
>        if ( (!(((&regs->psw)->states & ( 1 << (3) )) != 0) || ((&regs->psw)->sysmask & 0x04)==0) || (arn == 19) )
>            regs->tlb.pte[(ix)].F.L.F = addr & 0x00E00000;
>
>
>        if (arn > 0 && arn < 16 && ( ((((regs))->siebk->mx) & (0x01)) && (((&(regs)->psw)->asc & ( 1 << (6) )) != 0) ))
>        {
>            regs->tlb.asd[(ix)].F.L.F = regs->dat.asd;
>
>            regs->dat.private = regs->hostregs->dat.private;
>
>
>            regs->dat.asd = regs->hostregs->dat.asd ^ 0x800;
>            regs->cr[(16 + arn)].F.L.F = regs->dat.asd;
>            regs->aea_ar[arn] = 16 + arn;
>            regs->aea_common[16 + arn] = (regs->dat.asd & 0x00000002) == 0;
>            regs->aea_aleprot[arn] = regs->hostregs->dat.protect & 2;
>        }
>
>
>        regs->hostregs->dat.aaddr = aaddr =
>              ( ((U32)(regs->hostregs->dat.raddr) & 0x7FFFF000) == 0 || ((U32)(regs->hostregs->dat.raddr) & 0x7FFFF000) == (regs->hostregs->px.F.L.F) ? (U32)(regs->hostregs->dat.raddr) ^ (regs->hostregs->px.F.L.F) : (regs->hostregs->dat.raddr) );
>        apfra = ( ((U32)(regs->hostregs->dat.rpfra) & 0x7FFFF000) == 0 || ((U32)(regs->hostregs->dat.rpfra) & 0x7FFFF000) == (regs->hostregs->px.F.L.F) ? (U32)(regs->hostregs->dat.rpfra) ^ (regs->hostregs->px.F.L.F) : (regs->hostregs->dat.rpfra) );
>
>        if(regs->hostregs->dat.aaddr > regs->hostregs->mainlim)
>            goto vabs_addr_excp;
>
>
>
>
>        if((addr & 0x7FFFF800) & 0x800)
>        {
>            apfra|=0x800;
>        }
>
>    }
>
>
>
>    regs->dat.storkey = &((regs)->storkeys[(aaddr)>>11]);
>
>
>
>    if (__builtin_expect(((0)),0))
>        return regs->mainstor + aaddr;
>
>
>    if (__builtin_expect((acctype & 0x0004),1))
>    {
>
>        if (__builtin_expect((s370_is_fetch_protected (addr, *regs->dat.storkey, akey, regs)),0))
>        {
>            if (__builtin_expect(((regs)->sie_mode),0)) regs->hostregs->dat.protect = 0;
>            goto vabs_prot_excp;
>        }
>
>
>        *regs->dat.storkey |= 0x04;
>
>
>        regs->tlb.storkey[ix] = regs->dat.storkey;
>        regs->tlb.skey[ix] = *regs->dat.storkey & 0xF0;
>        regs->tlb.acc[ix] = 0x0004;
>        regs->tlb.main[ix] = (BYTE*)((uintptr_t)((regs)->mainstor + (uintptr_t)(apfra)) ^ (uintptr_t)((addr) & 0x00FFF800));
>
>    }
>    else
>    {
>
>        if (__builtin_expect((s370_is_store_protected (addr, *regs->dat.storkey, akey, regs)),0))
>        {
>            if (__builtin_expect(((regs)->sie_mode),0)) regs->hostregs->dat.protect = 0;
>            goto vabs_prot_excp;
>        }
>        if (__builtin_expect(((regs)->sie_mode),0) && regs->hostregs->dat.protect)
>            goto vabs_prot_excp;
>
>
>        if (acctype & 0x0002)
>            *regs->dat.storkey |= (0x04 | 0x02);
>
>
>        regs->tlb.storkey[ix] = regs->dat.storkey;
>        regs->tlb.skey[ix] = *regs->dat.storkey & 0xF0;
>        regs->tlb.acc[ix] = (addr >= 4096 || regs->dat.private)
>                              ? (0x0004|0x0001|acctype)
>                              : 0x0004;
>        regs->tlb.main[ix] = (BYTE*)((uintptr_t)((regs)->mainstor + (uintptr_t)(apfra)) ^ (uintptr_t)((addr) & 0x00FFF800));
>
>
>        if (( __builtin_expect(((regs)->permode),0) && ((regs)->ints_state & ( 1 << (21) )) ))
>        {
>            regs->tlb.acc[ix] = 0x0004;
>            if (arn != 19
>
>
>
>
>
>
>            && ( (((regs->cr[(11)].F.L.F) & 0x00FFFFFF) >= ((regs->cr[(10)].F.L.F) & 0x00FFFFFF)) ? (((addr) >= ((regs->cr[(10)].F.L.F) & 0x00FFFFFF)) && (addr) <= ((regs->cr[(11)].F.L.F) & 0x00FFFFFF)) || (((addr+(len-1)) >= ((regs->cr[(10)].F.L.F) & 0x00FFFFFF)) && (addr+(len-1)) <= ((regs->cr[(11)].F.L.F) & 0x00FFFFFF)) || (((addr) <= ((regs->cr[(10)].F.L.F) & 0x00FFFFFF)) && (addr+(len-1)) >= ((regs->cr[(11)].F.L.F) & 0x00FFFFFF)) : (((addr+(len-1)) >= ((regs->cr[(10)].F.L.F) & 0x00FFFFFF)) || (addr) <= ((regs->cr[(11)].F.L.F) & 0x00FFFFFF)) )
>            )
>                do { (regs)->ints_mask |= ( 1 << (21) ); } while (0);
>        }
>
>    }
>
>
>    return regs->mainstor + aaddr;
>
>vabs_addr_excp:
>    regs->program_interrupt (regs, 0x0005);
>
>vabs_prot_excp:
># 2404 "dat.h"
>    if(__builtin_expect(((regs)->sie_mode),0) && regs->hostregs->dat.protect)
>    {
>
>
>
>
>        (regs->hostregs->program_interrupt) (regs->hostregs, 0x0004);
>    }
>    else
>
>        regs->program_interrupt (regs, 0x0004);
>
>vabs_prog_check:
>    regs->program_interrupt (regs, regs->dat.xcode);
>
>    return ((void *)0);
>}
>
>
>static inline BYTE *s370_logical_to_main (U32 addr, int arn,
>                                    REGS *regs, int acctype, BYTE akey)
>{
>    return s370_logical_to_main_l(addr,arn,regs,acctype,akey,1);
>}
># 735 "inline.h" 2
>
># 1 "vstore.h" 1
># 153 "vstore.h"
>static inline void s370_vstorec (void *src, BYTE len,
>                                        U32 addr, int arn, REGS *regs)
>{
>BYTE *main1, *main2;
>BYTE *sk;
>int len2;
>
>    if ( __builtin_expect((( (int)((addr) & 0x7FF)) <= ( 0x7FF - (len) )),1) )
>    {
>        memcpy(( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].F.L.F == (regs)->tlb.asd[((((U32)(addr) >> 11) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 11) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 11) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0x00E00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)(addr) >> 11) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 11) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 11) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( s370_logical_to_main_l ((addr), (arn), (regs), (0x0002), (regs->psw.pkey), (len+1)) ) ),
>               src, len + 1);
>        do { if( (__builtin_expect((__builtin_expect((((addr)) < 84),0) && ((((addr)) + ((len))) >= 80)),0)) ) s370_fetch_int_timer ((regs)); } while(0);
>    }
>    else
>    {
>        len2 = 0x800 - (addr & 0x7FF);
>        main1 = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].F.L.F == (regs)->tlb.asd[((((U32)(addr) >> 11) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 11) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 11) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0x00E00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0001) & (regs)->tlb.acc[(((U32)(addr) >> 11) & 0x3FF)]),1) ? ( ((0x0001) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 11) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 11) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( s370_logical_to_main_l ((addr), (arn), (regs), (0x0001), (regs->psw.pkey), (len2)) ) )
>                                     ;
>        sk = regs->dat.storkey;
>        main2 = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].F.L.F == (regs)->tlb.asd[((((U32)((addr + len2) & (0x00FFFFFF)) >> 11) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)((addr + len2) & (0x00FFFFFF)) >> 11) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)((addr + len2) & (0x00FFFFFF)) >> 11) & 0x3FF)]),1) && __builtin_expect((((((addr + len2) & (0x00FFFFFF)) & 0x00E00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)((addr + len2) & (0x00FFFFFF)) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)((addr + len2) & (0x00FFFFFF)) >> 11) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)((addr + len2) & (0x00FFFFFF)) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)((addr + len2) & (0x00FFFFFF)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr + len2) & (0x00FFFFFF)))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)((addr + len2) & (0x00FFFFFF)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr + len2) & (0x00FFFFFF)))) ) : ( s370_logical_to_main_l (((addr + len2) & (0x00FFFFFF)), (arn), (regs), (0x0002), (regs->psw.pkey), (len+1-len2)) ) )
>
>                                                          ;
>        *sk |= (0x04 | 0x02);
>        memcpy (main1, src, len2);
>        memcpy (main2, (BYTE*)src + len2, len + 1 - len2);
>    }
>
>}
># 195 "vstore.h"
>static inline void s370_vstoreb (BYTE value, U32 addr,
>                                         int arn, REGS *regs)
>{
>BYTE *main1;
>
>    main1 = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 11) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 11) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0002)) & ((regs))->tlb.acc[(((U32)((addr)) >> 11) & 0x3FF)]),1) ? ( (((0x0002)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s370_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0002)), ((regs->psw.pkey)), (1)) ) );
>    *main1 = value;
>    do { if( (__builtin_expect((__builtin_expect((((addr)) < 84),0) && ((((addr)) + ((1-1))) >= 80)),0)) ) s370_fetch_int_timer ((regs)); } while(0);
>
>}
># 219 "vstore.h"
>static void s370_vstore2_full(U16 value, U32 addr,
>                                              int arn, REGS *regs)
>{
>BYTE *main1, *main2;
>BYTE *sk;
>
>    main1 = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 11) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 11) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0001)) & ((regs))->tlb.acc[(((U32)((addr)) >> 11) & 0x3FF)]),1) ? ( (((0x0001)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s370_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0001)), ((regs->psw.pkey)), (1)) ) );
>    sk = regs->dat.storkey;
>    main2 = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)(((addr + 1) & (0x00FFFFFF))) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)(((addr + 1) & (0x00FFFFFF))) >> 11) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)(((addr + 1) & (0x00FFFFFF))) >> 11) & 0x3FF)]),1) && __builtin_expect(((((((addr + 1) & (0x00FFFFFF))) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr + 1) & (0x00FFFFFF))) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0002)) & ((regs))->tlb.acc[(((U32)(((addr + 1) & (0x00FFFFFF))) >> 11) & 0x3FF)]),1) ? ( (((0x0002)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr + 1) & (0x00FFFFFF))) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + 1) & (0x00FFFFFF))) >> 11) & 0x3FF)]) ^ (uintptr_t)((((addr + 1) & (0x00FFFFFF))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + 1) & (0x00FFFFFF))) >> 11) & 0x3FF)]) ^ (uintptr_t)((((addr + 1) & (0x00FFFFFF))))) ) : ( s370_logical_to_main_l ((((addr + 1) & (0x00FFFFFF))), ((arn)), ((regs)), ((0x0002)), ((regs->psw.pkey)), (1)) ) )
>                                                ;
>    *sk |= (0x04 | 0x02);
>    *main1 = value >> 8;
>    *main2 = value & 0xFF;
>
>}
>
>
>static inline void s370_vstore2 (U16 value, U32 addr, int arn,
>                                                            REGS *regs)
>{
>
>    if (__builtin_expect((!((U32)addr & 1) || ((U32)addr & 0x7FF) != 0x7FF),1))
>    {
>        BYTE *mn;
>        mn = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].F.L.F == (regs)->tlb.asd[((((U32)(addr) >> 11) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 11) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 11) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0x00E00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)(addr) >> 11) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 11) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 11) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( s370_logical_to_main_l ((addr), (arn), (regs), (0x0002), (regs->psw.pkey), (2)) ) );
>        store_hw_noswap((mn), (__extension__ ({ unsigned short int __v, __x = (unsigned short int) ((value)); if (__builtin_constant_p (__x)) __v = ((unsigned short int) ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8))); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })));
>        do { if( (__builtin_expect((__builtin_expect((((addr)) < 84),0) && ((((addr)) + ((2-1))) >= 80)),0)) ) s370_fetch_int_timer ((regs)); } while(0);
>    }
>    else
>        s370_vstore2_full(value, addr, arn, regs);
>}
># 264 "vstore.h"
>static void s370_vstore4_full(U32 value, U32 addr,
>                                              int arn, REGS *regs)
>{
>BYTE *main1, *main2;
>BYTE *sk;
>int len;
>BYTE temp[4];
>
>    len = 0x800 - (addr & 0x7FF);
>    main1 = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].F.L.F == (regs)->tlb.asd[((((U32)(addr) >> 11) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 11) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 11) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0x00E00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0001) & (regs)->tlb.acc[(((U32)(addr) >> 11) & 0x3FF)]),1) ? ( ((0x0001) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 11) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 11) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( s370_logical_to_main_l ((addr), (arn), (regs), (0x0001), (regs->psw.pkey), (len)) ) );
>    sk = regs->dat.storkey;
>    main2 = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].F.L.F == (regs)->tlb.asd[((((U32)((addr + len) & (0x00FFFFFF)) >> 11) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)((addr + len) & (0x00FFFFFF)) >> 11) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)((addr + len) & (0x00FFFFFF)) >> 11) & 0x3FF)]),1) && __builtin_expect((((((addr + len) & (0x00FFFFFF)) & 0x00E00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)((addr + len) & (0x00FFFFFF)) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)((addr + len) & (0x00FFFFFF)) >> 11) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)((addr + len) & (0x00FFFFFF)) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)((addr + len) & (0x00FFFFFF)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr + len) & (0x00FFFFFF)))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)((addr + len) & (0x00FFFFFF)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr + len) & (0x00FFFFFF)))) ) : ( s370_logical_to_main_l (((addr + len) & (0x00FFFFFF)), (arn), (regs), (0x0002), (regs->psw.pkey), (4-len)) ) )
>                                                ;
>    *sk |= (0x04 | 0x02);
>    store_fw_noswap((temp), __bswap_32 ((value)));
>    memcpy(main1, temp, len);
>    memcpy(main2, temp+len, 4-len);
>
>}
>
>
>static inline void s370_vstore4 (U32 value, U32 addr, int arn,
>                                                            REGS *regs)
>{
>
>    if(__builtin_expect((!((U32)addr & 0x03)),1) || (((U32)addr & 0x7ff) <= 0x7fc))
>    {
>        BYTE *mn;
>        mn = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].F.L.F == (regs)->tlb.asd[((((U32)(addr) >> 11) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 11) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 11) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0x00E00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)(addr) >> 11) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 11) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 11) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( s370_logical_to_main_l ((addr), (arn), (regs), (0x0002), (regs->psw.pkey), (4)) ) );
>        store_fw_noswap((mn), __bswap_32 ((value)));
>        do { if( (__builtin_expect((__builtin_expect((((addr)) < 84),0) && ((((addr)) + ((4-1))) >= 80)),0)) ) s370_fetch_int_timer ((regs)); } while(0);
>    }
>    else
>        s370_vstore4_full(value,addr,arn,regs);
>}
># 316 "vstore.h"
>static void s370_vstore8_full(U64 value, U32 addr,
>                                              int arn, REGS *regs)
>{
>BYTE *main1, *main2;
>BYTE *sk;
>int len;
>BYTE temp[8];
>
>    len = 0x800 - (addr & 0x7FF);
>    main1 = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].F.L.F == (regs)->tlb.asd[((((U32)(addr) >> 11) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 11) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 11) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0x00E00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0001) & (regs)->tlb.acc[(((U32)(addr) >> 11) & 0x3FF)]),1) ? ( ((0x0001) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 11) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 11) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( s370_logical_to_main_l ((addr), (arn), (regs), (0x0001), (regs->psw.pkey), (len)) ) );
>    sk = regs->dat.storkey;
>    main2 = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].F.L.F == (regs)->tlb.asd[((((U32)((addr + len) & (0x00FFFFFF)) >> 11) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)((addr + len) & (0x00FFFFFF)) >> 11) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)((addr + len) & (0x00FFFFFF)) >> 11) & 0x3FF)]),1) && __builtin_expect((((((addr + len) & (0x00FFFFFF)) & 0x00E00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)((addr + len) & (0x00FFFFFF)) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)((addr + len) & (0x00FFFFFF)) >> 11) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)((addr + len) & (0x00FFFFFF)) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)((addr + len) & (0x00FFFFFF)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr + len) & (0x00FFFFFF)))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)((addr + len) & (0x00FFFFFF)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr + len) & (0x00FFFFFF)))) ) : ( s370_logical_to_main_l (((addr + len) & (0x00FFFFFF)), (arn), (regs), (0x0002), (regs->psw.pkey), (8-len)) ) )
>                                                ;
>    *sk |= (0x04 | 0x02);
>    store_dw_i686_noswap((temp),__bswap_64 ((value)));
>    memcpy(main1, temp, len);
>    memcpy(main2, temp+len, 8-len);
>
>}
>static inline void s370_vstore8 (U64 value, U32 addr, int arn,
>                                                            REGS *regs)
>{
>
>
>
>    if(__builtin_expect((!((U32)addr & 0x07)),1))
>    {
>
>        U64 *mn;
>        mn = (U64*)( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].F.L.F == (regs)->tlb.asd[((((U32)(addr) >> 11) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 11) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 11) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0x00E00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)(addr) >> 11) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 11) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 11) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( s370_logical_to_main_l ((addr), (arn), (regs), (0x0002), (regs->psw.pkey), (8)) ) );
>        if (regs->cpubit == regs->sysblk->started_mask)
>            *mn = __bswap_64 (value);
>        else
>        store_dw_i686_noswap((mn),__bswap_64 ((value)));
>    }
>    else
>
>    {
>
>
>
>
>
>        if(__builtin_expect((((U32)addr & 0x7ff) <= 0x7f8),1))
>        {
>
>            BYTE *mn;
>            mn = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].F.L.F == (regs)->tlb.asd[((((U32)(addr) >> 11) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 11) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 11) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0x00E00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)(addr) >> 11) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 11) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 11) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( s370_logical_to_main_l ((addr), (arn), (regs), (0x0002), (regs->psw.pkey), (8)) ) );
>
>            store_dw_i686_noswap((mn),__bswap_64 ((value)));
>        }
>        else
>
>            s370_vstore8_full(value,addr,arn,regs);
>    }
>    do { if( (__builtin_expect((__builtin_expect((((addr)) < 84),0) && ((((addr)) + ((8-1))) >= 80)),0)) ) s370_fetch_int_timer ((regs)); } while(0);
>}
># 389 "vstore.h"
>static inline void s370_vfetchc (void *dest, BYTE len,
>                                        U32 addr, int arn, REGS *regs)
>{
>BYTE *main1, *main2;
>int len2;
>
>    main1 = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 11) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 11) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 11) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s370_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>
>    if ( __builtin_expect((( (int)((addr) & 0x7FF)) <= ( 0x7FF - (len) )),1) )
>    {
>        do { if( (__builtin_expect((__builtin_expect((((addr)) < 84),0) && ((((addr)) + ((len))) >= 80)),0)) ) s370_store_int_timer ((regs)); } while (0);
>        memcpy (dest, main1, len + 1);
>    }
>    else
>    {
>        len2 = 0x800 - (addr & 0x7FF);
>        main2 = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)(((addr + len2) & (0x00FFFFFF))) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)(((addr + len2) & (0x00FFFFFF))) >> 11) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)(((addr + len2) & (0x00FFFFFF))) >> 11) & 0x3FF)]),1) && __builtin_expect(((((((addr + len2) & (0x00FFFFFF))) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr + len2) & (0x00FFFFFF))) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)(((addr + len2) & (0x00FFFFFF))) >> 11) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr + len2) & (0x00FFFFFF))) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len2) & (0x00FFFFFF))) >> 11) & 0x3FF)]) ^ (uintptr_t)((((addr + len2) & (0x00FFFFFF))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len2) & (0x00FFFFFF))) >> 11) & 0x3FF)]) ^ (uintptr_t)((((addr + len2) & (0x00FFFFFF))))) ) : ( s370_logical_to_main_l ((((addr + len2) & (0x00FFFFFF))), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) )
>                                                               ;
>        memcpy (dest, main1, len2);
>        memcpy ((BYTE*)dest + len2, main2, len + 1 - len2);
>    }
>
>}
># 427 "vstore.h"
>static inline BYTE s370_vfetchb (U32 addr, int arn,
>                                         REGS *regs)
>{
>BYTE *mn;
>
>    do { if( (__builtin_expect((__builtin_expect((((addr)) < 84),0) && ((((addr)) + ((1-1))) >= 80)),0)) ) s370_store_int_timer ((regs)); } while (0);
>    mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 11) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 11) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 11) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s370_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>    return *mn;
>}
># 451 "vstore.h"
>static U16 s370_vfetch2_full (U32 addr, int arn,
>                                             REGS *regs)
>{
>BYTE *mn;
>U16 value;
>
>    mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 11) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 11) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 11) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s370_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>    value = *mn << 8;
>    mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)(((addr + 1) & (0x00FFFFFF))) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)(((addr + 1) & (0x00FFFFFF))) >> 11) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)(((addr + 1) & (0x00FFFFFF))) >> 11) & 0x3FF)]),1) && __builtin_expect(((((((addr + 1) & (0x00FFFFFF))) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr + 1) & (0x00FFFFFF))) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)(((addr + 1) & (0x00FFFFFF))) >> 11) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr + 1) & (0x00FFFFFF))) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + 1) & (0x00FFFFFF))) >> 11) & 0x3FF)]) ^ (uintptr_t)((((addr + 1) & (0x00FFFFFF))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + 1) & (0x00FFFFFF))) >> 11) & 0x3FF)]) ^ (uintptr_t)((((addr + 1) & (0x00FFFFFF))))) ) : ( s370_logical_to_main_l ((((addr + 1) & (0x00FFFFFF))), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) )
>                                              ;
>    value |= *mn;
>    return value;
>
>}
>
>static inline U16 s370_vfetch2 (U32 addr, int arn, REGS *regs)
>{
>    if(__builtin_expect((!((U32)addr & 0x01)),1) || (((U32)addr & 0x7ff) !=0x7ff ))
>    {
>    BYTE *mn;
>        do { if( (__builtin_expect((__builtin_expect((((addr)) < 84),0) && ((((addr)) + ((2-1))) >= 80)),0)) ) s370_store_int_timer ((regs)); } while (0);
>        mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 11) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 11) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 11) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s370_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>        return (__extension__ ({ unsigned short int __v, __x = (unsigned short int) (fetch_hw_noswap((mn))); if (__builtin_constant_p (__x)) __v = ((unsigned short int) ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8))); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; }));
>    }
>    return(s370_vfetch2_full(addr,arn,regs));
>}
># 492 "vstore.h"
>static U32 s370_vfetch4_full (U32 addr, int arn,
>                                             REGS *regs)
>{
>BYTE *mn;
>int len;
>BYTE temp[8];
>
>    mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 11) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 11) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 11) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s370_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>    memcpy(temp, mn, 4);
>    len = 0x800 - (addr & 0x7FF);
>    mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF)]),1) && __builtin_expect(((((((addr + len) & (0x00FFFFFF))) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF)]) ^ (uintptr_t)((((addr + len) & (0x00FFFFFF))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF)]) ^ (uintptr_t)((((addr + len) & (0x00FFFFFF))))) ) : ( s370_logical_to_main_l ((((addr + len) & (0x00FFFFFF))), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) )
>                                              ;
>    memcpy(temp+len, mn, 4);
>    return __bswap_32 (fetch_fw_noswap((temp)));
>
>}
>
>static inline U32 s370_vfetch4 (U32 addr, int arn, REGS *regs)
>{
>    if ( (__builtin_expect((!((U32)addr & 0x03)),1) || (((U32)addr & 0x7ff) <= 0x7fc )))
>    {
>    BYTE *mn;
>        do { if( (__builtin_expect((__builtin_expect((((addr)) < 84),0) && ((((addr)) + ((4-1))) >= 80)),0)) ) s370_store_int_timer ((regs)); } while (0);
>        mn=( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 11) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 11) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 11) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s370_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>        return __bswap_32 (fetch_fw_noswap((mn)));
>    }
>    return(s370_vfetch4_full(addr,arn,regs));
>}
># 535 "vstore.h"
>static U64 s370_vfetch8_full (U32 addr, int arn,
>                                             REGS *regs)
>{
>BYTE *mn;
>int len;
>BYTE temp[16];
>
>
>    mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 11) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 11) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 11) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s370_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>    memcpy(temp, mn, 8);
>    len = 0x800 - (addr & 0x7FF);
>    mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF)]),1) && __builtin_expect(((((((addr + len) & (0x00FFFFFF))) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF)]) ^ (uintptr_t)((((addr + len) & (0x00FFFFFF))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF)]) ^ (uintptr_t)((((addr + len) & (0x00FFFFFF))))) ) : ( s370_logical_to_main_l ((((addr + len) & (0x00FFFFFF))), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) )
>                                             ;
>    memcpy(temp+len, mn, 8);
>    return __bswap_64 (fetch_dw_i686_noswap((temp)));
>
>}
>
>static inline U64 s370_vfetch8 (U32 addr, int arn, REGS *regs)
>{
>
>    if(__builtin_expect((!((U32)addr & 0x07)),1))
>    {
>
>        U64 *mn;
>        do { if( (__builtin_expect((__builtin_expect((((addr)) < 84),0) && ((((addr)) + ((8-1))) >= 80)),0)) ) s370_store_int_timer ((regs)); } while (0);
>        mn=(U64*)( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 11) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 11) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 11) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s370_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>        if (regs->cpubit == regs->sysblk->started_mask)
>            return __bswap_64 (*mn);
>        return __bswap_64 (fetch_dw_i686_noswap((mn)));
>    }
>    else
>
>    {
>
>        if(__builtin_expect((((U32)addr & 0x7ff) <= 0x7f8),1))
>        {
>
>            BYTE *mn;
>            do { if( (__builtin_expect((__builtin_expect((((addr)) < 84),0) && ((((addr)) + ((8-1))) >= 80)),0)) ) s370_store_int_timer ((regs)); } while (0);
>            mn=( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 11) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 11) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 11) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s370_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>            return __bswap_64 (fetch_dw_i686_noswap((mn)));
>        }
>    }
>
>    return s370_vfetch8_full(addr,arn,regs);
>}
># 623 "vstore.h"
>static inline BYTE * s370_instfetch (REGS *regs, int exec)
>{
>U32 addr;
>BYTE *ia;
>BYTE *dest;
>int pagesz;
>int offset;
>int len;
>
>    while (0);
>
>    addr = exec ? regs->et.F.L.F
>         : __builtin_expect((regs->aie == ((void *)0)),1) ? regs->psw.ia.F.L.F : ((U32)(((regs))->aiv.F.L.F + ((intptr_t)((regs))->ip - (intptr_t)((regs))->aip) + ((0))) & (0x00FFFFFF));
>
>    offset = (int)(addr & 0x000007FF);
>
>
>    if ( __builtin_expect((offset & 0x01),0) )
>    {
>        if (!exec) regs->instinvalid = 1;
>        regs->program_interrupt(regs, 0x0006);
>    }
>    pagesz = __builtin_expect((addr < 0x800),0) ? 0x800 : 2048;
>
>
>
>    if( __builtin_expect(((regs)->permode),0) )
>    {
># 659 "vstore.h"
>        regs->perc = 0;
>
>
>        if(!exec)
>            regs->peradr = addr;
>
>
>        if( ( __builtin_expect(((regs)->permode),0) && ((regs)->ints_state & ( 1 << (22) )) )
>          && ( (((regs->cr[(11)].F.L.F) & 0x00FFFFFF) >= ((regs->cr[(10)].F.L.F) & 0x00FFFFFF)) ? (((addr) >= ((regs->cr[(10)].F.L.F) & 0x00FFFFFF)) && (addr) <= ((regs->cr[(11)].F.L.F) & 0x00FFFFFF)) : (((addr) >= ((regs->cr[(10)].F.L.F) & 0x00FFFFFF)) || (addr) <= ((regs->cr[(11)].F.L.F) & 0x00FFFFFF)) ) )
>        {
>            do { (regs)->ints_mask |= ( 1 << (22) ); } while (0);
># 682 "vstore.h"
>        }
>
>        if (!exec && !regs->tracing
>         && regs->aie && regs->ip < regs->aip + pagesz - 5)
>            return regs->ip;
>    }
>
>
>    if (!exec) regs->instinvalid = 1;
>
>
>    ia = ( __builtin_expect((((regs))->aea_ar[((20))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((20))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((20))]] & ((regs))->tlb.common[(((U32)((addr)) >> 11) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 11) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 11) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s370_logical_to_main_l (((addr)), ((20)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>
>
>    if ( offset + ((ia[0]) < 0x40 ? 2 : (ia[0]) < 0xc0 ? 4 : 6) > pagesz )
>    {
>
>        dest = exec ? regs->exinst : regs->inst;
>        memcpy (dest, ia, 4);
>        len = pagesz - offset;
>        offset = 0;
>        addr = (addr + len) & (0x00FFFFFF);
>        ia = ( __builtin_expect((((regs))->aea_ar[((20))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((20))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((20))]] & ((regs))->tlb.common[(((U32)((addr)) >> 11) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 11) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 11) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s370_logical_to_main_l (((addr)), ((20)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>        if (!exec) regs->ip = ia - len;
>        memcpy(dest + len, ia, 4);
>    }
>    else
>    {
>        dest = ia;
>        if (!exec) regs->ip = ia;
>    }
>
>    if (!exec)
>    {
>        regs->instinvalid = 0;
>
>
>        regs->aiv.F.L.F = addr & 0x7FFFF800;
>        regs->aip = (BYTE *)((uintptr_t)ia & ~0x000007FF);
>        regs->aim = (uintptr_t)regs->aip ^ (uintptr_t)regs->aiv.F.L.F;
>        if (__builtin_expect((!regs->tracing && !regs->permode),1))
>            regs->aie = regs->aip + pagesz - 5;
>        else
>        {
>            regs->aie = (BYTE *)1;
>            if (regs->tracing)
>                s370_process_trace(regs);
>        }
>    }
>
>    return dest;
>
>}
># 743 "vstore.h"
>static __inline__ void concpy (REGS *regs, void *d, void *s, int n)
>{
> int n2;
> BYTE *dest = (BYTE *)d, *src = (BYTE *)s;
>
>
>    if (n < 8
>     || (dest <= src && dest + 8 > src)
>     || (src <= dest && src + 8 > dest))
>    {
>
>
>        if(dest==src+1)
>        {
>            memset(dest,*src,n);
>        }
>        else
>        {
>            for ( ; n; n--)
>                *(dest++) = *(src++);
>        }
>        return;
>    }
>
>
>    n2 = (intptr_t)dest & 7;
>    n -= n2;
>    for ( ; n2; n2--)
>        *(dest++) = *(src++);
># 793 "vstore.h"
>    if (regs->cpubit == regs->sysblk->started_mask)
>        for ( ; n >= 4; n -= 4, dest += 4, src += 4)
>            *(U32 *)dest = *(U32 *)src;
>    else
>
>
>
>
>
>
>        for ( ; n >= 8; n -= 8, dest += 8, src += 8)
>            store_dw_i686_noswap(dest,fetch_dw_i686_noswap(src));
>
>
>
>
>    for ( ; n; n--)
>        *(dest++) = *(src++);
>}
># 852 "vstore.h"
>static inline void s370_move_chars (U32 addr1, int arn1,
>       BYTE key1, U32 addr2, int arn2, BYTE key2, int len, REGS *regs)
>{
>BYTE *dest1, *dest2;
>BYTE *source1, *source2;
>BYTE *sk1, *sk2;
>int len2, len3;
>
>    do { if( (__builtin_expect((__builtin_expect((((addr2)) < 84),0) && ((((addr2)) + ((len))) >= 80)),0)) ) s370_store_int_timer ((regs)); } while (0);
>
>
>    if (__builtin_expect((len == 0),0))
>    {
>        source1 = ( __builtin_expect((((regs))->aea_ar[((arn2))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn2))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr2)) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn2))]] & ((regs))->tlb.common[(((U32)((addr2)) >> 11) & 0x3FF)])),1) && __builtin_expect((((key2)) == 0 || ((key2)) == ((regs))->tlb.skey[(((U32)((addr2)) >> 11) & 0x3FF)]),1) && __builtin_expect((((((addr2)) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr2)) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr2)) >> 11) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr2)) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr2)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr2)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr2)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr2)))) ) : ( s370_logical_to_main_l (((addr2)), ((arn2)), ((regs)), ((0x0004)), ((key2)), (1)) ) );
>        dest1 = ( __builtin_expect((((regs))->aea_ar[((arn1))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn1))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr1)) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn1))]] & ((regs))->tlb.common[(((U32)((addr1)) >> 11) & 0x3FF)])),1) && __builtin_expect((((key1)) == 0 || ((key1)) == ((regs))->tlb.skey[(((U32)((addr1)) >> 11) & 0x3FF)]),1) && __builtin_expect((((((addr1)) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr1)) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0002)) & ((regs))->tlb.acc[(((U32)((addr1)) >> 11) & 0x3FF)]),1) ? ( (((0x0002)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr1)) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr1)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr1)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr1)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr1)))) ) : ( s370_logical_to_main_l (((addr1)), ((arn1)), ((regs)), ((0x0002)), ((key1)), (1)) ) );
>        *dest1 = *source1;
>        do { if( (__builtin_expect((__builtin_expect((((addr1)) < 84),0) && ((((addr1)) + ((len))) >= 80)),0)) ) s370_fetch_int_timer ((regs)); } while(0);
>        return;
>    }
>
>
>    source1 = ( __builtin_expect((((regs))->aea_ar[((arn2))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn2))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr2)) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn2))]] & ((regs))->tlb.common[(((U32)((addr2)) >> 11) & 0x3FF)])),1) && __builtin_expect((((key2)) == 0 || ((key2)) == ((regs))->tlb.skey[(((U32)((addr2)) >> 11) & 0x3FF)]),1) && __builtin_expect((((((addr2)) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr2)) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr2)) >> 11) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr2)) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr2)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr2)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr2)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr2)))) ) : ( s370_logical_to_main_l (((addr2)), ((arn2)), ((regs)), ((0x0004)), ((key2)), (1)) ) );
>    dest1 = ( __builtin_expect(((regs)->aea_ar[(arn1)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn1)])].F.L.F == (regs)->tlb.asd[((((U32)(addr1) >> 11) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn1)]] & (regs)->tlb.common[(((U32)(addr1) >> 11) & 0x3FF)])),1) && __builtin_expect(((key1) == 0 || (key1) == (regs)->tlb.skey[(((U32)(addr1) >> 11) & 0x3FF)]),1) && __builtin_expect(((((addr1) & 0x00E00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr1) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0001) & (regs)->tlb.acc[(((U32)(addr1) >> 11) & 0x3FF)]),1) ? ( ((0x0001) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr1) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr1) >> 11) & 0x3FF)]) ^ (uintptr_t)((addr1))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr1) >> 11) & 0x3FF)]) ^ (uintptr_t)((addr1))) ) : ( s370_logical_to_main_l ((addr1), (arn1), (regs), (0x0001), (key1), (len+1)) ) );
>    sk1 = regs->dat.storkey;
># 889 "vstore.h"
>    if ( __builtin_expect((( (int)((addr1) & 0x7FF)) <= ( 0x7FF - (len) )),1) )
>    {
>        if ( __builtin_expect((( (int)((addr2) & 0x7FF)) <= ( 0x7FF - (len) )),1) )
>        {
>
>            concpy (regs, dest1, source1, len + 1);
>        }
>        else
>        {
>
>            len2 = 0x800 - (addr2 & 0x7FF);
>            source2 = ( __builtin_expect((((regs))->aea_ar[((arn2))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn2))])].F.L.F == ((regs))->tlb.asd[((((U32)(((addr2 + len2) & (0x00FFFFFF))) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn2))]] & ((regs))->tlb.common[(((U32)(((addr2 + len2) & (0x00FFFFFF))) >> 11) & 0x3FF)])),1) && __builtin_expect((((key2)) == 0 || ((key2)) == ((regs))->tlb.skey[(((U32)(((addr2 + len2) & (0x00FFFFFF))) >> 11) & 0x3FF)]),1) && __builtin_expect(((((((addr2 + len2) & (0x00FFFFFF))) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr2 + len2) & (0x00FFFFFF))) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)(((addr2 + len2) & (0x00FFFFFF))) >> 11) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr2 + len2) & (0x00FFFFFF))) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr2 + len2) & (0x00FFFFFF))) >> 11) & 0x3FF)]) ^ (uintptr_t)((((addr2 + len2) & (0x00FFFFFF))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr2 + len2) & (0x00FFFFFF))) >> 11) & 0x3FF)]) ^ (uintptr_t)((((addr2 + len2) & (0x00FFFFFF))))) ) : ( s370_logical_to_main_l ((((addr2 + len2) & (0x00FFFFFF))), ((arn2)), ((regs)), ((0x0004)), ((key2)), (1)) ) )
>                                                             ;
>            concpy (regs, dest1, source1, len2);
>            concpy (regs, dest1 + len2, source2, len - len2 + 1);
>        }
>        *sk1 |= (0x04 | 0x02);
>    }
>    else
>    {
>
>        len2 = 0x800 - (addr1 & 0x7FF);
>        dest2 = ( __builtin_expect((((regs))->aea_ar[((arn1))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn1))])].F.L.F == ((regs))->tlb.asd[((((U32)(((addr1 + len2) & (0x00FFFFFF))) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn1))]] & ((regs))->tlb.common[(((U32)(((addr1 + len2) & (0x00FFFFFF))) >> 11) & 0x3FF)])),1) && __builtin_expect((((key1)) == 0 || ((key1)) == ((regs))->tlb.skey[(((U32)(((addr1 + len2) & (0x00FFFFFF))) >> 11) & 0x3FF)]),1) && __builtin_expect(((((((addr1 + len2) & (0x00FFFFFF))) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr1 + len2) & (0x00FFFFFF))) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0001)) & ((regs))->tlb.acc[(((U32)(((addr1 + len2) & (0x00FFFFFF))) >> 11) & 0x3FF)]),1) ? ( (((0x0001)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr1 + len2) & (0x00FFFFFF))) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr1 + len2) & (0x00FFFFFF))) >> 11) & 0x3FF)]) ^ (uintptr_t)((((addr1 + len2) & (0x00FFFFFF))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr1 + len2) & (0x00FFFFFF))) >> 11) & 0x3FF)]) ^ (uintptr_t)((((addr1 + len2) & (0x00FFFFFF))))) ) : ( s370_logical_to_main_l ((((addr1 + len2) & (0x00FFFFFF))), ((arn1)), ((regs)), ((0x0001)), ((key1)), (1)) ) )
>                                                           ;
>        sk2 = regs->dat.storkey;
>
>        if ( __builtin_expect((( (int)((addr2) & 0x7FF)) <= ( 0x7FF - (len) )),1) )
>        {
>
>             concpy (regs, dest1, source1, len2);
>             concpy (regs, dest2, source1 + len2, len - len2 + 1);
>        }
>        else
>        {
>
>            len3 = 0x800 - (addr2 & 0x7FF);
>            source2 = ( __builtin_expect((((regs))->aea_ar[((arn2))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn2))])].F.L.F == ((regs))->tlb.asd[((((U32)(((addr2 + len3) & (0x00FFFFFF))) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn2))]] & ((regs))->tlb.common[(((U32)(((addr2 + len3) & (0x00FFFFFF))) >> 11) & 0x3FF)])),1) && __builtin_expect((((key2)) == 0 || ((key2)) == ((regs))->tlb.skey[(((U32)(((addr2 + len3) & (0x00FFFFFF))) >> 11) & 0x3FF)]),1) && __builtin_expect(((((((addr2 + len3) & (0x00FFFFFF))) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr2 + len3) & (0x00FFFFFF))) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)(((addr2 + len3) & (0x00FFFFFF))) >> 11) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr2 + len3) & (0x00FFFFFF))) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr2 + len3) & (0x00FFFFFF))) >> 11) & 0x3FF)]) ^ (uintptr_t)((((addr2 + len3) & (0x00FFFFFF))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr2 + len3) & (0x00FFFFFF))) >> 11) & 0x3FF)]) ^ (uintptr_t)((((addr2 + len3) & (0x00FFFFFF))))) ) : ( s370_logical_to_main_l ((((addr2 + len3) & (0x00FFFFFF))), ((arn2)), ((regs)), ((0x0004)), ((key2)), (1)) ) )
>                                                            ;
>            if (len2 == len3)
>            {
>
>                concpy (regs, dest1, source1, len2);
>                concpy (regs, dest2, source2, len - len2 + 1);
>            }
>            else if (len2 < len3)
>            {
>
>                concpy (regs, dest1, source1, len2);
>                concpy (regs, dest2, source1 + len2, len3 - len2);
>                concpy (regs, dest2 + len3 - len2, source2, len - len3 + 1);
>            }
>            else
>            {
>
>                concpy (regs, dest1, source1, len3);
>                concpy (regs, dest1 + len3, source2, len2 - len3);
>                concpy (regs, dest2, source2 + len2 - len3, len - len2 + 1);
>            }
>        }
>        *sk1 |= (0x04 | 0x02);
>        *sk2 |= (0x04 | 0x02);
>    }
>    do { if( (__builtin_expect((__builtin_expect((((addr1)) < 84),0) && ((((addr1)) + ((len))) >= 80)),0)) ) s370_fetch_int_timer ((regs)); } while(0);
>
>}
># 1073 "vstore.h"
>static inline void s370_validate_operand (U32 addr, int arn,
>                                      int len, int acctype, REGS *regs)
>{
>
>    ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 11) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 11) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((acctype)) & ((regs))->tlb.acc[(((U32)((addr)) >> 11) & 0x3FF)]),1) ? ( (((acctype)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 11) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s370_logical_to_main_l (((addr)), ((arn)), ((regs)), ((acctype)), ((regs->psw.pkey)), (1)) ) );
>
>
>    if ( __builtin_expect((( (int)((addr) & 0x7FF)) > ( 0x7FF - (len) )),0) )
>    {
>        ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF)]),1) && __builtin_expect(((((((addr + len) & (0x00FFFFFF))) & 0x00E00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF))].F.L.F),1) && __builtin_expect((((acctype)) & ((regs))->tlb.acc[(((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF)]),1) ? ( (((acctype)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF)]) ^ (uintptr_t)((((addr + len) & (0x00FFFFFF))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len) & (0x00FFFFFF))) >> 11) & 0x3FF)]) ^ (uintptr_t)((((addr + len) & (0x00FFFFFF))))) ) : ( s370_logical_to_main_l ((((addr + len) & (0x00FFFFFF))), ((arn)), ((regs)), ((acctype)), ((regs->psw.pkey)), (1)) ) )
>                                                  ;
>    }
>
>    else
>        do { if( (__builtin_expect((__builtin_expect((((addr)) < 84),0) && ((((addr)) + ((len))) >= 80)),0)) ) s370_store_int_timer ((regs)); } while (0);
>
>}
># 737 "inline.h" 2
># 43 "cpu.c" 2
>
>
>
>
>
>void s370_checkstop_cpu(REGS *regs)
>{
>    regs->cpustate=2;
>    regs->checkstop=1;
>    do { (regs)->ints_state |= ( 1 << (31) ); } while (0);
>}
>
>
>
>void s370_checkstop_config(void)
>{
>    int i;
>    for(i=0;i<sysblk.maxcpu;i++)
>    {
>        if((sysblk.regs[(i)] != ((void *)0)))
>        {
>            s370_checkstop_cpu(sysblk.regs[i]);
>        }
>    }
>    do { int i; CPU_BITMAP mask = (sysblk.waiting_mask); for (i = 0; mask; i++) { if (mask & 1) ptt_pthread_cond_signal((&sysblk.regs[i]->intcond),"cpu.c" ":" "67"); mask >>= 1; } } while (0);
>}
>
>
>
>
>void s370_store_psw (REGS *regs, BYTE *addr)
>{
>
>
>    if (!regs->psw.zeroilc)
>        do { if ((regs)->aie) (regs)->psw.ia.F.L.F = ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((0))) & (0x00FFFFFF)); } while (0);
>
>
>    if ( (((&regs->psw)->states & ( 1 << (3) )) != 0) ) {
>
>
>        store_fw_noswap((addr), __bswap_32 ((( (regs->psw.sysmask << 24) | ((regs->psw.pkey | regs->psw.states) << 16) | ( ( (regs->psw.asc) | (regs->psw.cc << 4) | (regs->psw.progmask) ) << 8 ) | regs->psw.zerobyte ))))
># 94 "cpu.c"
>                  ;
>        if(__builtin_expect((regs->psw.zeroilc),0))
>            store_fw_noswap((addr + 4), __bswap_32 ((regs->psw.ia.F.L.F | (regs->psw.amode ? 0x80000000 : 0))));
>        else
>            store_fw_noswap((addr + 4), __bswap_32 ((( (regs->psw.ia.F.L.F & (0x00FFFFFF)) | (regs->psw.amode ? 0x80000000 : 0) ))))
>
>                  ;
>
>
>    } else {
>        store_fw_noswap((addr), __bswap_32 ((( (regs->psw.sysmask << 24) | ((regs->psw.pkey | regs->psw.states) << 16) | (regs->psw.intcode) ))))
>
>
>
>
>                  ;
>        if(__builtin_expect((regs->psw.zeroilc),0))
>            store_fw_noswap((addr + 4), __bswap_32 ((( ( ((__builtin_expect((!(regs)->execflag),1) ? (regs)->psw.ilc : (regs)->exrl ? 6 : 4) << 5) | (regs->psw.cc << 4) | regs->psw.progmask ) << 24 ) | regs->psw.ia.F.L.F)))
>
>
>
>
>
>                  ;
>        else
>            store_fw_noswap((addr + 4), __bswap_32 ((( ( ((__builtin_expect((!(regs)->execflag),1) ? (regs)->psw.ilc : (regs)->exrl ? 6 : 4) << 5) | (regs->psw.cc << 4) | regs->psw.progmask ) << 24 ) | (regs->psw.ia.F.L.F & (0x00FFFFFF)))))
>
>
>
>
>
>                  ;
>    }
># 147 "cpu.c"
>}
>
>
>
>
>
>int s370_load_psw (REGS *regs, BYTE *addr)
>{
>    do { if ((regs)->aie) { (regs)->psw.ia.F.L.F = ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((0))) & (0x00FFFFFF)); (regs)->aie = ((void *)0); } } while (0);
>
>    regs->psw.zeroilc = 1;
>
>    regs->psw.sysmask = addr[0];
>    regs->psw.pkey = (addr[1] & 0xF0);
>    regs->psw.states = (addr[1] & 0x0F);
>
>
>    if ( (((&regs->psw)->states & ( 1 << (3) )) != 0) ) {
>
>
>        do { (regs)->ints_mask = ( ( ( ( 1 << (31) ) | ( 1 << (1) ) | ( 1 << (3) ) ) ) | ( (((regs))->psw.sysmask & 0x02) ? ( 1 << (30) ) : 0 ) | ( (((&((regs))->psw)->states & ( 1 << (2) )) != 0) ? (((regs))->cr[(14)].F.L.F & ( ( 1 << (28) ) | ( 1 << (27) ) | ( 1 << (26) ) | ( 1 << (25) ) | ( 1 << (24) ) )) : 0 ) | ( ( ((((&(((regs)))->psw)->states & ( 1 << (3) )) != 0) && ((((regs)))->psw.sysmask & 0x40)) || (__builtin_expect((((((regs))))->sie_mode),0) && ((((regs)))->siebk->m & 0x01)) ) ? (((regs))->ints_mask & ( ( 1 << (23) ) | ( 1 << (22) ) | ( 1 << (21) ) | ( 1 << (20) ) | ( 1 << (19) ) | ( 1 << (16) ) )) : 0 ) | ( (((regs))->psw.sysmask & 0x01) ? (( ( (((regs)))->cr[(0)].F.L.F & ( ( 1 << (15) ) | ( 1 << (14) ) | ( 1 << (13) ) | ( 1 << (12) ) | ( 1 << (11) ) | ( 1 << (10) ) | ( 1 << (9) ) | ( 1 << (7) ) | ( 1 << (6) ) | ( 1 << (5) ) | ( 1 << (4) ) )) | (((((regs)))->cr[(0)].F.L.F & ( 1 << (7) )) ? ( 1 << (8) ) : 0) )) : 0 ) | ( (((&((regs))->psw)->states & ( 1 << (1) )) != 0) ? ( 1 << (0) ) : 0 ) ); if ( ( (regs)->permode = ( ((((&((regs))->psw)->states & ( 1 << (3) )) != 0) && (((regs))->psw.sysmask & 0x40)) || (__builtin_expect(((((regs)))->sie_mode),0) && (((regs))->siebk->m & 0x01)) ) ) ) do { if (((regs))->aie) { ((regs))->psw.ia.F.L.F = ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((0))) & (0x00FFFFFF)); ((regs))->aie = ((void *)0); } } while (0); } while (0);
>
>
>        regs->psw.intcode = 0;
>        regs->psw.asc = (addr[2] & 0xC0);
>        regs->psw.cc = (addr[2] & 0x30) >> 4;
>        regs->psw.progmask = (addr[2] & 0x0F);
>        regs->psw.amode = (addr[4] & 0x80) ? 1 : 0;
># 184 "cpu.c"
>        regs->psw.zerobyte = addr[3];
>        regs->psw.amode64 = 0;
>        regs->psw.ia.F.L.F = __bswap_32 (fetch_fw_noswap((addr + 4))) & 0x7FFFFFFF;
>        regs->psw.amask.F.L.F = regs->psw.amode ? 0x7FFFFFFF : 0x00FFFFFF;
>
>
>
>        if ((addr[0] & 0xB8) != 0)
>            return 0x0006;
># 208 "cpu.c"
>        if ( regs->psw.zerobyte )
>            return 0x0006;
>
>
>        if (!(((&regs->psw)->states & ( 1 << (3) )) != 0))
>            return 0x0006;
># 224 "cpu.c"
>        if ((((&regs->psw)->asc & ( 1 << (6) )) != 0))
>            return 0x0006;
># 249 "cpu.c"
>        if (addr[4] != 0x00)
>            return 0x0006;
>
>
>
>
>    } else {
>
>        do { (regs)->ints_mask = ( ( ( ( 1 << (31) ) | ( 1 << (1) ) | ( 1 << (3) ) ) ) | ( (((regs))->psw.sysmask & 0xFE) ? ( 1 << (30) ) : 0 ) | ( (((&((regs))->psw)->states & ( 1 << (2) )) != 0) ? (((regs))->cr[(14)].F.L.F & ( ( 1 << (28) ) | ( 1 << (27) ) | ( 1 << (26) ) | ( 1 << (25) ) | ( 1 << (24) ) )) : 0 ) | ( ( ((((&(((regs)))->psw)->states & ( 1 << (3) )) != 0) && ((((regs)))->psw.sysmask & 0x40)) || (__builtin_expect((((((regs))))->sie_mode),0) && ((((regs)))->siebk->m & 0x01)) ) ? (((regs))->ints_mask & ( ( 1 << (23) ) | ( 1 << (22) ) | ( 1 << (21) ) | ( 1 << (20) ) | ( 1 << (19) ) | ( 1 << (16) ) )) : 0 ) | ( (((regs))->psw.sysmask & 0x01) ? (( ( (((regs)))->cr[(0)].F.L.F & ( ( 1 << (15) ) | ( 1 << (14) ) | ( 1 << (13) ) | ( 1 << (12) ) | ( 1 << (11) ) | ( 1 << (10) ) | ( 1 << (9) ) | ( 1 << (7) ) | ( 1 << (6) ) | ( 1 << (5) ) | ( 1 << (4) ) )) | (((((regs)))->cr[(0)].F.L.F & ( 1 << (7) )) ? ( 1 << (8) ) : 0) )) : 0 ) | ( (((&((regs))->psw)->states & ( 1 << (1) )) != 0) ? ( 1 << (0) ) : 0 ) ); if ( ( (regs)->permode = ( ((((&((regs))->psw)->states & ( 1 << (3) )) != 0) && (((regs))->psw.sysmask & 0x40)) || (__builtin_expect(((((regs)))->sie_mode),0) && (((regs))->siebk->m & 0x01)) ) ) ) do { if (((regs))->aie) { ((regs))->psw.ia.F.L.F = ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((0))) & (0x00FFFFFF)); ((regs))->aie = ((void *)0); } } while (0); } while (0);
>
>
>        regs->psw.intcode = (__extension__ ({ unsigned short int __v, __x = (unsigned short int) (fetch_hw_noswap((addr + 2))); if (__builtin_constant_p (__x)) __v = ((unsigned short int) ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8))); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; }));
>        regs->psw.cc = (addr[4] & 0x30) >> 4;
>        regs->psw.progmask = (addr[4] & 0x0F);
>
>        (regs->psw.ia.F.L.F) = __bswap_32 (fetch_fw_noswap((addr + 4)));
>        regs->psw.ia.F.L.F &= 0x00FFFFFF;
>        regs->psw.amask.F.L.F = 0x00FFFFFF;
>
>        regs->psw.zerobyte = 0;
>        regs->psw.asc = 0;
>        regs->psw.amode64 = regs->psw.amode = 0;
>    }
># 281 "cpu.c"
>    regs->psw.zeroilc = 0;
>
>
>    if ((((&regs->psw)->states & ( 1 << (1) )) != 0) && ( (sysblk.insttrace && sysblk.traceaddr[0] == 0 && sysblk.traceaddr[1] == 0) || (sysblk.inststep && sysblk.stepaddr[0] == 0 && sysblk.stepaddr[1] == 0) ))
>    {
>        logmsg (("HHCCP043I Wait state PSW loaded: "));
>        display_psw (regs);
>    }
>
>    do { if ((regs)->aea_mode != ( ( (!(((&((regs))->psw)->states & ( 1 << (3) )) != 0) || ((&((regs))->psw)->sysmask & 0x04)==0) ? ((__builtin_expect((((((regs))))->sie_mode),0) && ((((((regs))))->siebk->mx) & (0x01)) ) && (((&((regs))->psw)->asc & ( 1 << (6) )) != 0) ? 2 : 0) : ((((regs))->psw.asc >> 6) + 1) ) | ( ( ((((&(((regs)))->psw)->states & ( 1 << (3) )) != 0) && ((((regs)))->psw.sysmask & 0x40)) || (__builtin_expect((((((regs))))->sie_mode),0) && ((((regs)))->siebk->m & 0x01)) ) ? 0x40 : 0 ) )) { do { int i; int inst_cr = ((regs))->aea_ar[20]; BYTE oldmode = ((regs))->aea_mode; ((regs))->aea_mode = ( ( (!(((&(((regs)))->psw)->states & ( 1 << (3) )) != 0) || ((&(((regs)))->psw)->sysmask & 0x04)==0) ? ((__builtin_expect(((((((regs)))))->sie_mode),0) && (((((((regs)))))->siebk->mx) & (0x01)) ) && (((&(((regs)))->psw)->asc & ( 1 << (6) )) != 0) ? 2 : 0) : (((((regs)))->psw.asc >> 6) + 1) ) | ( ( ((((&((((regs))))->psw)->states & ( 1 << (3) )) != 0) && (((((regs))))->psw.sysmask & 0x40)) || (__builtin_expect(((((((regs)))))->sie_mode),0) && (((((regs))))->siebk->m & 0x01)) ) ? 0x40 : 0 ) ); switch (((regs))->aea_mode & 0x0F) { case 1: ((regs))->aea_ar[20] = 1; for(i = 0; i < 16; i++) ((regs))->aea_ar[i] = 1; break; case 3: (((regs)))->aea_ar[20] = 1; for(i = 0; i < 16; i++) (((regs)))->aea_ar[i] = 7; break; default: ((regs))->aea_ar[20] = 32; for(i = 0; i < 16; i++) ((regs))->aea_ar[i] = 32; } if (inst_cr != ((regs))->aea_ar[20]) do { if ((((regs)))->aie) { (((regs)))->psw.ia.F.L.F = ((U32)((((((regs)))))->aiv.F.L.F + ((intptr_t)(((((regs)))))->ip - (intptr_t)(((((regs)))))->aip) + ((0))) & (0x00FFFFFF)); (((regs)))->aie = ((void *)0); } } while (0); if ((oldmode & 0x40) == 0 && (((regs))->aea_mode & 0x40) != 0) { do { if ((((regs)))->aie) { (((regs)))->psw.ia.F.L.F = ((U32)((((((regs)))))->aiv.F.L.F + ((intptr_t)(((((regs)))))->ip - (intptr_t)(((((regs)))))->aip) + ((0))) & (0x00FFFFFF)); (((regs)))->aie = ((void *)0); } } while (0); if (( __builtin_expect(((((regs)))->permode),0) && ((((regs)))->ints_state & ( 1 << (21) )) )) s370_invalidate_tlb(((regs)),~(0x0002|0x0001)); } } while (0); } } while (0);
>
>    return 0;
>}
>
>
>
>
>void (__attribute__ (( regparm(2) )) s370_program_interrupt) (REGS *regs, int pcode)
>{
>PSA_3XX *psa;
>REGS *realregs;
>U64 px;
>int code;
>int ilc;
># 317 "cpu.c"
>int nointercept;
>
>
>
>
>char dxcstr[8]={0};
>
>static char *pgmintname[] = {
>                        "Operation exception",
>                        "Privileged-operation exception",
>                        "Execute exception",
>                        "Protection exception",
>                        "Addressing exception",
>                        "Specification exception",
>                        "Data exception",
>                        "Fixed-point-overflow exception",
>                        "Fixed-point-divide exception",
>                        "Decimal-overflow exception",
>                        "Decimal-divide exception",
>                        "HFP-exponent-overflow exception",
>                        "HFP-exponent-underflow exception",
>                        "HFP-significance exception",
>                        "HFP-floating-point-divide exception",
>                        "Segment-translation exception",
>                        "Page-translation exception",
>                        "Translation-specification exception",
>                        "Special-operation exception",
>                        "Pseudo-page-fault exception",
>                        "Operand exception",
>                        "Trace-table exception",
>                        "ASN-translation exception",
>                        "Page access exception",
>                        "Vector/Crypto operation exception",
>                        "Page state exception",
>                        "Page transition exception",
>                        "Space-switch event",
>                        "Square-root exception",
>                        "Unnormalized-operand exception",
>                        "PC-translation specification exception",
>                        "AFX-translation exception",
>                        "ASX-translation exception",
>                        "LX-translation exception",
>                        "EX-translation exception",
>                        "Primary-authority exception",
>                        "Secondary-authority exception",
>                        "LFX-translation exception",
>                        "LSX-translation exception",
>                        "ALET-specification exception",
>                        "ALEN-translation exception",
>                        "ALE-sequence exception",
>                        "ASTE-validity exception",
>                        "ASTE-sequence exception",
>                        "Extended-authority exception",
>                        "LSTE-sequence exception",
>                        "ASTE-instance exception",
>                        "Stack-full exception",
>                        "Stack-empty exception",
>                        "Stack-specification exception",
>                        "Stack-type exception",
>                        "Stack-operation exception",
>                        "Unassigned exception",
>                        "Unassigned exception",
>                        "Unassigned exception",
>                        "ASCE-type exception",
>                        "Region-first-translation exception",
>                        "Region-second-translation exception",
>                        "Region-third-translation exception",
>                        "Unassigned exception",
>                        "Unassigned exception",
>                        "Unassigned exception",
>                        "Unassigned exception",
>                        "Monitor event" };
>
>
>
>
>
>
>
>    if(regs->ghostregs)
>        longjmp(regs->progjmp, pcode);
>
>    do { if (pttclass & (0x0400)) ptt_pthread_trace(0x0400,"*PROG",(void *)(uintptr_t)(pcode),(void *)(uintptr_t)((U32)(regs->ea.F.L.F & 0xffffffff)),"cpu.c" ":" "399",(int)(regs->psw.ia.F.L.F)); } while(0);
>
>
>
>
>
>
>        realregs = __builtin_expect(((regs)->sie_mode),0)
>                 ? sysblk.regs[regs->cpuad]->guestregs
>                 : sysblk.regs[regs->cpuad];
>
>
>
>
>
>    realregs->instcount++;
>
>
>    if (sysblk.intowner == realregs->cpuad)
>        do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "418"); } while (0);
>    if (sysblk.mainowner == realregs->cpuad)
>        do { if ((realregs)->sysblk->mainowner == (realregs)->hostregs->cpuad) { (realregs)->sysblk->mainowner = 0xFFFF; ptt_pthread_mutex_unlock((&(realregs)->sysblk->mainlock),"cpu.c" ":" "420"); } } while (0);
>
>
>    do { if ((realregs)->aie) { (realregs)->psw.ia.F.L.F = ((U32)((((realregs)))->aiv.F.L.F + ((intptr_t)(((realregs)))->ip - (intptr_t)(((realregs)))->aip) + ((0))) & (0x00FFFFFF)); (realregs)->aie = ((void *)0); } } while (0);
>
>
>
>
>
>
>    ilc = realregs->psw.zeroilc ? 0 : (__builtin_expect((!(realregs)->execflag),1) ? (realregs)->psw.ilc : (realregs)->exrl ? 6 : 4);
>    if (realregs->psw.ilc == 0 && !realregs->psw.zeroilc)
>    {
>
>
>        ilc = realregs->execflag ? realregs->exrl ? 6 : 4 : 2;
>        realregs->ip += ilc;
>        realregs->psw.ia.F.L.F += ilc;
>        realregs->psw.ilc = ilc;
>    }
># 457 "cpu.c"
>    realregs->execflag = 0;
>
>
>
>
>
>
>    if (realregs->cpuad == sysblk.mainowner)
>        do { if ((realregs)->sysblk->mainowner == (realregs)->hostregs->cpuad) { (realregs)->sysblk->mainowner = 0xFFFF; ptt_pthread_mutex_unlock((&(realregs)->sysblk->mainlock),"cpu.c" ":" "465"); } } while (0);
>
>
>
>
>
>    code = pcode & ~0x0080;
>
>
>
>    if( ( (realregs)->ints_state & (realregs)->ints_mask & ( ( 1 << (23) ) | ( 1 << (22) ) | ( 1 << (21) ) | ( 1 << (20) ) | ( 1 << (19) ) | ( 1 << (16) ) ) ) )
>        pcode |= 0x0080;
>
>
>    do { } while (0);
>    do { } while (0);
># 511 "cpu.c"
>    if ((code == 0x0011
>      || code == 0x0010
>
>
>
>
>
>
>      || code == 0x0016
>      || code == 0x0020
>      || code == 0x0021
>      || code == 0x0022
>      || code == 0x0026
>      || code == 0x0027
>      || code == 0x002E
>      || code == 0x0023
>      || code == 0x0024
>      || code == 0x0025
>      || code == 0x0029
>      || code == 0x002A
>      || code == 0x002B
>      || code == 0x002C
>      || code == 0x002F
>      || code == 0x002D
>      || code == 0x0030
>      || code == 0x0031
>      || code == 0x0032
>      || code == 0x0033
>      || code == 0x0034
>      || code == 0x0019)
>      && !realregs->instinvalid)
>    {
>        realregs->psw.ia.F.L.F -= ilc;
>        realregs->psw.ia.F.L.F &= (0x00FFFFFF);
># 554 "cpu.c"
>    }
>
>
>
>    if(realregs->instinvalid &&
>      ( code == 0x0004
>      || code == 0x0005
>      || code == 0x0006
>      || code == 0x0012 ))
>    {
>        realregs->psw.ia.F.L.F += ilc;
>        realregs->psw.ia.F.L.F &= (0x00FFFFFF);
>    }
>
>
>    realregs->psw.intcode = pcode;
>
>
>    ((debug_program_interrupt) ? (debug_program_interrupt) ((regs),(pcode)) : (((void *)0)));
>
>
>    if(code && (( __builtin_expect(((realregs)->tracing),0) && (( sysblk.inststep && ( (sysblk.stepaddr[0] == 0 && sysblk.stepaddr[1] == 0) || (sysblk.stepaddr[0] <= sysblk.stepaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (0x00FFFFFF)) >= sysblk.stepaddr[0] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (0x00FFFFFF)) <= sysblk.stepaddr[1] ) || (sysblk.stepaddr[0] > sysblk.stepaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (0x00FFFFFF)) >= sysblk.stepaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (0x00FFFFFF)) <= sysblk.stepaddr[0] ) ) ) || ( sysblk.insttrace && ( (sysblk.traceaddr[0] == 0 && sysblk.traceaddr[1] == 0) || (sysblk.traceaddr[0] <= sysblk.traceaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (0x00FFFFFF)) >= sysblk.traceaddr[0] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (0x00FFFFFF)) <= sysblk.traceaddr[1] ) || (sysblk.traceaddr[0] > sysblk.traceaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (0x00FFFFFF)) >= sysblk.traceaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (0x00FFFFFF)) <= sysblk.traceaddr[0] ) ) )) )
>        || sysblk.pgminttr & ((U64)1 << ((code - 1) & 0x3F))))
>    {
>     BYTE *ip;
># 588 "cpu.c"
>        logmsg(("HHCCP014I "));
>
>        if(__builtin_expect(((realregs)->sie_mode),0))
>            logmsg(("SIE: "));
>
>
>
>
>        if (code == 0x0007)
>            sprintf(dxcstr, " DXC=%2.2X", regs->dxc);
>        logmsg (("CPU%4.4X: %s CODE=%4.4X ILC=%d%s\n"), realregs->cpuad,
>                pgmintname[ (code - 1) & 0x3F], pcode, ilc, dxcstr);
>
>
>        ip = realregs->instinvalid ? ((void *)0)
>           : (realregs->ip - ilc < realregs->aip)
>             ? realregs->inst : realregs->ip - ilc;
>
>        s370_display_inst (realregs, ip);
>    }
>
>    realregs->instinvalid = 0;
># 618 "cpu.c"
>    px = realregs->px.F.L.F;
>
>
>
>    if(__builtin_expect(((regs)->sie_mode),0))
>        px = regs->sie_px;
>
>
>
>    if(!__builtin_expect(((regs)->sie_mode),0) ||
>
>      (
>
>         !(code == 0x0004
>           && (!(((regs)->siebk->ec[2]) & (0x20))
>             || realregs->hostint))
>
>
>
>
>      && !((pcode & 0x0080) && (((regs)->siebk->m) & (0x01)))
>
>      && code != 0x0005
>      && code != 0x0006
>      && code != 0x0013
># 655 "cpu.c"
>      && !(code == 0x0001
>        && (((regs)->siebk->ic[0]) & (0x80)))
>      && !(code == 0x0002
>        && (((regs)->siebk->ic[0]) & (0x40)))
>
>
>
>
>
>
>
>      && !(((regs)->siebk->ic[0]) & (0x20)) )
>    )
>    {
>
>
>        (regs)->storkeys[(px)>>11] |= (0x04 | 0x02);
>
>
>        psa = (void*)(regs->mainstor + px);
># 683 "cpu.c"
>        nointercept = 1;
>    }
>    else
>    {
>
>
>
>        if(code != 0x0001)
>        {
>            psa = (void*)(regs->hostregs->mainstor + ((regs)->sie_state) + 0x40);
>
>            (regs->hostregs)->storkeys[(((regs)->sie_state))>>11] |= (0x04 | 0x02);
># 704 "cpu.c"
>        }
>        else
>        {
>
>            psa = (void*)(regs->mainstor + px);
>
>
>            (regs)->storkeys[(px)>>11] |= (0x04 | 0x02);
>        }
>
>        nointercept = 0;
>    }
>
>
>
>
>
>
>    if ( ( (realregs)->ints_mask & ( 1 << (21) ) ) && !( (realregs)->ints_mask & ( 1 << (19) ) ) &&
>                                   (realregs->ip[0] != 0x0E) &&
>         !(code == 0x00 || code == 0x06 || code == 0x08 || code == 0x0A ||
>           code == 0x0C || code == 0x0D || code == 0x0E || code == 0x1C ||
>           code == 0x40) )
>              do { (realregs)->ints_mask &= ~( 1 << (21) ); } while (0);
>
>    if( ( (realregs)->ints_state & (realregs)->ints_mask & ( ( 1 << (23) ) | ( 1 << (22) ) | ( 1 << (21) ) | ( 1 << (20) ) | ( 1 << (19) ) | ( 1 << (16) ) ) ) )
>    {
>        if( ( __builtin_expect(((realregs)->tracing),0) && (( sysblk.inststep && ( (sysblk.stepaddr[0] == 0 && sysblk.stepaddr[1] == 0) || (sysblk.stepaddr[0] <= sysblk.stepaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (0x00FFFFFF)) >= sysblk.stepaddr[0] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (0x00FFFFFF)) <= sysblk.stepaddr[1] ) || (sysblk.stepaddr[0] > sysblk.stepaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (0x00FFFFFF)) >= sysblk.stepaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (0x00FFFFFF)) <= sysblk.stepaddr[0] ) ) ) || ( sysblk.insttrace && ( (sysblk.traceaddr[0] == 0 && sysblk.traceaddr[1] == 0) || (sysblk.traceaddr[0] <= sysblk.traceaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (0x00FFFFFF)) >= sysblk.traceaddr[0] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (0x00FFFFFF)) <= sysblk.traceaddr[1] ) || (sysblk.traceaddr[0] > sysblk.traceaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (0x00FFFFFF)) >= sysblk.traceaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (0x00FFFFFF)) <= sysblk.traceaddr[0] ) ) )) ) )
>            logmsg(("HHCCP015I CPU%4.4X PER event: code=%4.4X perc=%2.2X " "addr=" "%8.8""""X" "\n")
>                                         ,
>              regs->cpuad, pcode, ( (realregs)->ints_mask & ( ( 1 << (23) ) | ( 1 << (22) ) | ( 1 << (21) ) | ( 1 << (20) ) | ( 1 << (19) ) | ( 1 << (16) ) ) ) >> 16,
>              (realregs->psw.ia.F.L.F - ilc) & (0x00FFFFFF) );
>
>        realregs->perc |= ( (realregs)->ints_state & (realregs)->ints_mask & ( ( 1 << (23) ) | ( 1 << (22) ) | ( 1 << (21) ) | ( 1 << (20) ) | ( 1 << (19) ) | ( 1 << (16) ) ) ) >> ((32 - 8) - 16);
>
>
>
>
>        if( !(( (realregs)->ints_state & (realregs)->ints_mask & ( 1 << (21) ) ))
>          || (( (realregs)->ints_state & (realregs)->ints_mask & ( 1 << (19) ) )) )
>            realregs->perc &= 0xFFFC;
>
>        store_hw_noswap((psa->perint), (__extension__ ({ unsigned short int __v, __x = (unsigned short int) ((realregs->perc)); if (__builtin_constant_p (__x)) __v = ((unsigned short int) ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8))); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })));
>
>        store_fw_noswap((psa->peradr), __bswap_32 ((realregs->peradr)));
>
>        if( ( (realregs)->ints_mask & ( 1 << (21) ) ) && ((&realregs->psw)->asc == 0x40) )
>            psa->perarid = realregs->peraid;
>
>
>
>        if(nointercept)
>            do { (realregs)->ints_mask &= ~( ( 1 << (23) ) | ( 1 << (22) ) | ( 1 << (21) ) | ( 1 << (20) ) | ( 1 << (19) ) | ( 1 << (16) ) ); } while (0);
>
>    }
>    else
>    {
>        pcode &= 0xFF7F;
>    }
>
>
>
>
>
>    if ( (((&realregs->psw)->states & ( 1 << (3) )) != 0) )
>
>    {
>
>        psa->pgmint[0] = 0;
>        psa->pgmint[1] = ilc;
>        store_hw_noswap((psa->pgmint + 2), (__extension__ ({ unsigned short int __v, __x = (unsigned short int) ((pcode)); if (__builtin_constant_p (__x)) __v = ((unsigned short int) ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8))); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })));
>
>
>        if ( code == 0x0011
>          || code == 0x0010
>
>
>
>
>
>
>          || code == 0x0029
>          || code == 0x002A
>          || code == 0x002B
>          || code == 0x002C
>          || code == 0x002F
>          || code == 0x002D
>
>
>
>           )
>        {
>            psa->excarid = regs->excarid;
>            if(regs->ea.F.L.F | 0x004)
>                psa->opndrid = regs->opndrid;
>            realregs->opndrid = 0;
>        }
># 834 "cpu.c"
>        if ( code == 0x0011
>          || code == 0x0010
>          || code == 0x0020
>          || code == 0x0021
>          || code == 0x0024
>          || code == 0x0025
>          || code == 0x001C
>          || code == 0x0022
>          || code == 0x0023
>
>
>
>           )
>        {
>            store_fw_noswap((psa->tea), __bswap_32 ((regs->ea.F.L.F)));
>        }
>
>        realregs->ea.F.L.F = 0;
>
>
>        if (code == 0x0007)
>        {
>            store_fw_noswap((psa->tea), __bswap_32 ((regs->dxc)));
># 865 "cpu.c"
>        }
>
>
>        if (code == 0x0040)
>        {
>            store_hw_noswap((psa->monclass), (__extension__ ({ unsigned short int __v, __x = (unsigned short int) ((regs->monclass)); if (__builtin_constant_p (__x)) __v = ((unsigned short int) ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8))); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })));
># 892 "cpu.c"
>            store_fw_noswap((psa->moncode), __bswap_32 ((regs->mc.F.L.F)));
>
>        }
>
>
>
>
>
>
>
>    }
>
>
>    realregs->hostint = 0;
>
>
>
>    if(nointercept)
>    {
>
>
>
>
>
>        s370_store_psw (realregs, psa->pgmold);
>
>
>        if ( (code = s370_load_psw (realregs, psa->pgmnew)) )
>        {
>
>            if(__builtin_expect(((realregs)->sie_mode),0))
>            {
>
>                longjmp(realregs->progjmp, pcode);
>            }
>            else
>
>            {
>                logmsg (("HHCCP016I CPU%4.4X: Program interrupt loop: "),
>                          realregs->cpuad);
>                display_psw (realregs);
>                do { REGS *_regs = (realregs); if ((_regs)) (_regs)->hostregs->intwait = 1; ptt_pthread_mutex_lock((&sysblk.intlock),"cpu.c" ":" "933"); if ((_regs)) { while (sysblk.syncing) { sysblk.sync_mask &= ~(_regs)->hostregs->cpubit; if (!sysblk.sync_mask) ptt_pthread_cond_signal((&sysblk.sync_cond),"cpu.c" ":" "933"); ptt_pthread_cond_wait((&sysblk.sync_bc_cond),(&sysblk.intlock),"cpu.c" ":" "933"); } (_regs)->hostregs->intwait = 0; sysblk.intowner = (_regs)->hostregs->cpuad; } else sysblk.intowner = 0xFFFE; } while (0);
>                realregs->cpustate = 2;
>                do { (realregs)->ints_state |= ( 1 << (31) ); } while (0);
>                do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "936"); } while (0);
>            }
>        }
>
>
>
>        longjmp(realregs->progjmp, (-1));
>
>
>    }
>
>    longjmp (realregs->progjmp, pcode);
>
>
>}
>
>
>
>
>static void s370_restart_interrupt (REGS *regs)
>{
>int rc;
>PSA_3XX *psa;
>
>    do { if (pttclass & (0x0100)) ptt_pthread_trace(0x0100,"*RESTART",(void *)(uintptr_t)(regs->cpuad),(void *)(uintptr_t)(regs->cpustate),"cpu.c" ":" "960",(int)(regs->psw.ia.F.L.F)); } while(0);
>
>
>    (regs)->storkeys[(regs->px.F.L.F)>>11] |= (0x04 | 0x02);
>
>
>    regs->psw.intcode = 0;
>
>
>    psa = (PSA_3XX*)(regs->mainstor + regs->px.F.L.F);
>
>
>    s370_store_psw (regs, psa->iplccw1);
>
>
>    rc = s370_load_psw (regs, psa->iplpsw);
>
>    if ( rc == 0)
>    {
>        regs->opinterv = 0;
>        regs->cpustate = 1;
>    }
>
>    do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "983"); } while (0);
>
>    if ( rc )
>        regs->program_interrupt(regs, rc);
>
>    longjmp (regs->progjmp, (-10));
>}
>
>
>
>
>
>
>void s370_perform_io_interrupt (REGS *regs)
>{
>int rc;
>int icode;
>PSA_3XX *psa;
>U32 ioparm;
>U32 ioid;
>U32 iointid;
>U64 pfx;
>DBLWRD csw;
>
>
>    icode = s370_present_io_interrupt (regs, &ioid, &ioparm, &iointid, csw);
>
>
>    if (icode == 0) return;
>
>    do { if (pttclass & (0x4000)) ptt_pthread_trace(0x4000,"*IOINT",(void *)(uintptr_t)(ioid),(void *)(uintptr_t)(ioparm),"cpu.c" ":" "1013",(int)(iointid)); } while(0);
>
>
>    if(__builtin_expect(((regs)->sie_mode),0) && icode != (-1))
>    {
>
>        psa = (void*)(regs->hostregs->mainstor + ((regs)->sie_state) + 0x30);
>        (regs->hostregs)->storkeys[(((regs)->sie_state))>>11] |= (0x04 | 0x02);
>    }
>    else
>
>    {
>
>        pfx =
>
>              __builtin_expect(((regs)->sie_mode),0) ? regs->sie_px :
>
>              regs->px.F.L.F;
>        psa = (void*)(regs->mainstor + pfx);
>        (regs)->storkeys[(pfx)>>11] |= (0x04 | 0x02);
>    }
>
>
>
>    memcpy (psa->csw, csw, 8);
>
>
>    regs->psw.intcode = ioid;
>
>
>    if ((((&regs->psw)->states & ( 1 << (3) )) != 0))
>        store_fw_noswap((psa->ioid), __bswap_32 ((ioid)));
>
>
>    if (( __builtin_expect(((regs)->tracing),0) && (( sysblk.inststep && ( (sysblk.stepaddr[0] == 0 && sysblk.stepaddr[1] == 0) || (sysblk.stepaddr[0] <= sysblk.stepaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (0x00FFFFFF)) >= sysblk.stepaddr[0] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (0x00FFFFFF)) <= sysblk.stepaddr[1] ) || (sysblk.stepaddr[0] > sysblk.stepaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (0x00FFFFFF)) >= sysblk.stepaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (0x00FFFFFF)) <= sysblk.stepaddr[0] ) ) ) || ( sysblk.insttrace && ( (sysblk.traceaddr[0] == 0 && sysblk.traceaddr[1] == 0) || (sysblk.traceaddr[0] <= sysblk.traceaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (0x00FFFFFF)) >= sysblk.traceaddr[0] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (0x00FFFFFF)) <= sysblk.traceaddr[1] ) || (sysblk.traceaddr[0] > sysblk.traceaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (0x00FFFFFF)) >= sysblk.traceaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (0x00FFFFFF)) <= sysblk.traceaddr[0] ) ) )) ))
>        logmsg (("HHCCP044I I/O interrupt code=%4.4X " "CSW=%2.2X%2.2X%2.2X%2.2X %2.2X%2.2X%2.2X%2.2X\n")
>                                                                  ,
>                regs->psw.intcode,
>                csw[0], csw[1], csw[2], csw[3],
>                csw[4], csw[5], csw[6], csw[7]);
># 1079 "cpu.c"
>    if(icode == (-1))
>
>    {
>
>        s370_store_psw ( regs, psa->iopold );
>
>
>        rc = s370_load_psw ( regs, psa->iopnew );
>
>        if ( rc )
>        {
>            do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1090"); } while (0);
>            regs->program_interrupt (regs, rc);
>        }
>    }
>
>    do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1095"); } while (0);
>
>    longjmp(regs->progjmp, icode);
>
>}
>
>
>
>
>
>static void s370_perform_mck_interrupt (REGS *regs)
>{
>int rc;
>PSA_3XX *psa;
>U64 mcic;
>U32 xdmg;
>U64 fsta;
>
>
>    rc = s370_present_mck_interrupt (regs, &mcic, &xdmg, &fsta);
>
>
>    if (rc == 0) return;
>
>
>    (regs)->storkeys[(regs->px.F.L.F)>>11] |= (0x04 | 0x02);
>
>
>    psa = (void*)(regs->mainstor + regs->px.F.L.F);
>
>
>    s370_store_status (regs, regs->px.F.L.F);
>
>
>
>
>    memset(psa->storepsw, 0, 16);
>
>
>
>    store_dw_i686_noswap((psa->mckint),__bswap_64 ((mcic)));
>
>
>    if (( __builtin_expect(((regs)->tracing),0) && (( sysblk.inststep && ( (sysblk.stepaddr[0] == 0 && sysblk.stepaddr[1] == 0) || (sysblk.stepaddr[0] <= sysblk.stepaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (0x00FFFFFF)) >= sysblk.stepaddr[0] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (0x00FFFFFF)) <= sysblk.stepaddr[1] ) || (sysblk.stepaddr[0] > sysblk.stepaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (0x00FFFFFF)) >= sysblk.stepaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (0x00FFFFFF)) <= sysblk.stepaddr[0] ) ) ) || ( sysblk.insttrace && ( (sysblk.traceaddr[0] == 0 && sysblk.traceaddr[1] == 0) || (sysblk.traceaddr[0] <= sysblk.traceaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (0x00FFFFFF)) >= sysblk.traceaddr[0] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (0x00FFFFFF)) <= sysblk.traceaddr[1] ) || (sysblk.traceaddr[0] > sysblk.traceaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (0x00FFFFFF)) >= sysblk.traceaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (0x00FFFFFF)) <= sysblk.traceaddr[0] ) ) )) ))
>        logmsg (("HHCCP022I Machine Check code=%16.16" "ll" "u\n"),
>                  (long long)mcic);
>
>
>    store_fw_noswap((psa->xdmgcode), __bswap_32 ((xdmg)));
>
>
>
>
>
>
>    store_fw_noswap((psa->mcstorad), __bswap_32 ((fsta)));
>
>
>
>    s370_store_psw ( regs, psa->mckold );
>
>
>    rc = s370_load_psw ( regs, psa->mcknew );
>
>    do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1159"); } while (0);
>
>    if ( rc )
>        regs->program_interrupt (regs, rc);
>
>    longjmp (regs->progjmp, (-11));
>}
>
>
>
>
>
>REGS *s370_run_cpu (int cpu, REGS *oldregs);
>REGS *s390_run_cpu (int cpu, REGS *oldregs);
>REGS *z900_run_cpu (int cpu, REGS *oldregs);
>static REGS *(* run_cpu[3+2]) (int cpu, REGS *oldregs) =
>                {
>
>                    s370_run_cpu,
>
>
>                    s390_run_cpu,
>
>
>                    z900_run_cpu
>
>                };
>
>
>
>
>void *cpu_thread (int *ptr)
>{
>REGS *regs = ((void *)0);
>int cpu = *ptr;
>
>    do { REGS *_regs = (((void *)0)); if ((_regs)) (_regs)->hostregs->intwait = 1; ptt_pthread_mutex_lock((&sysblk.intlock),"cpu.c" ":" "1195"); if ((_regs)) { while (sysblk.syncing) { sysblk.sync_mask &= ~(_regs)->hostregs->cpubit; if (!sysblk.sync_mask) ptt_pthread_cond_signal((&sysblk.sync_cond),"cpu.c" ":" "1195"); ptt_pthread_cond_wait((&sysblk.sync_bc_cond),(&sysblk.intlock),"cpu.c" ":" "1195"); } (_regs)->hostregs->intwait = 0; sysblk.intowner = (_regs)->hostregs->cpuad; } else sysblk.intowner = 0xFFFE; } while (0);
>
>
>    ptt_pthread_cond_signal((&sysblk.cpucond),"cpu.c" ":" "1198");
>
>
>    sysblk.cpus++;
>
>
>    if (cpu >= sysblk.hicpu)
>        sysblk.hicpu = cpu + 1;
>
>
>    if (!sysblk.todtid)
>    {
>        if ( ptt_pthread_create(&sysblk.todtid,&sysblk.detattr,(THREAD_FUNC*)&(timer_update_thread),((void *)0),("timer_update_thread"),
> "cpu.c"
># 1210 "cpu.c"
>             ":" "1211")
>                                                               )
>        {
>            logmsg (("HHCCP006S Cannot create timer thread: %s\n"),
>                           strerror((*__errno_location ())));
>            do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1215"); } while (0);
>            return ((void *)0);
>        }
>    }
>
>    do { setresuid(sysblk.suid,sysblk.suid,sysblk.ruid); } while(0);
>
>
>    if (setpriority(PRIO_PROCESS, 0, sysblk.cpuprio))
>        logmsg (("HHCCP001W CPU%4.4X thread set priority %d failed: %s\n"),
>                cpu, sysblk.cpuprio, strerror((*__errno_location ())));
>
>
>    do { setresuid(sysblk.ruid,sysblk.ruid,sysblk.suid); } while(0);
>
>
>    logmsg (("HHCCP002I CPU%4.4X thread started: tid=""%8.8lX"", pid=%d, " "priority=%d\n")
>                            ,
>            cpu, pthread_self(), getpid(),
>            getpriority(PRIO_PROCESS,0));
>
>
>    do {
>        regs = run_cpu[sysblk.arch_mode] (cpu, regs);
>    } while (regs);
>
>
>    sysblk.cpus--;
>
>
>    if (cpu + 1 >= sysblk.hicpu)
>    {
>        int i;
>        for (i = 8 - 1; i >= 0; i--)
>            if ((sysblk.regs[(i)] != ((void *)0)))
>                break;
>        sysblk.hicpu = i + 1;
>    }
>
>
>    ptt_pthread_cond_signal((&sysblk.cpucond),"cpu.c" ":" "1255");
>
>
>    logmsg (("HHCCP008I CPU%4.4X thread ended: tid=""%8.8lX"", pid=%d\n"),
>            cpu, pthread_self(), getpid());
>
>    do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1261"); } while (0);
>
>    return ((void *)0);
>}
>
>
>void s370_set_jump_pointers(REGS *regs, int jump);
>void s390_set_jump_pointers(REGS *regs, int jump);
>void z900_set_jump_pointers(REGS *regs, int jump);
>
>
>
>
>int cpu_init (int cpu, REGS *regs, REGS *hostregs)
>{
>int i;
>
>    ptt_pthread_mutex_lock((&sysblk.cpulock[cpu]),"cpu.c" ":" "1278");
>
>    regs->cpuad = cpu;
>    regs->cpubit = ( (( CPU_BITMAP ) ( 1 ) ) << ( cpu ) );
>    regs->arch_mode = sysblk.arch_mode;
>    regs->mainstor = sysblk.mainstor;
>    regs->sysblk = &sysblk;
>
>
>
>
>
>
>
>    regs->storkeys = sysblk.storkeys;
>    regs->mainlim = sysblk.mainsize - 1;
>    regs->tod_epoch = get_tod_epoch();
>
>    ptt_pthread_cond_init((&regs->intcond),((void *)0),"cpu.c" ":" "1296");
>    regs->cpulock = &sysblk.cpulock[cpu];
>
>
>
>
>
>    initial_cpu_reset(regs);
>
>    if (hostregs == ((void *)0))
>    {
>        regs->cpustate = 2;
>        do { (regs)->ints_state |= ( 1 << (31) ); } while (0);
>        regs->hostregs = regs;
>        regs->host = 1;
>        sysblk.regs[cpu] = regs;
>        sysblk.config_mask |= regs->cpubit;
>        sysblk.started_mask |= regs->cpubit;
>    }
>    else
>    {
>        hostregs->guestregs = regs;
>        regs->hostregs = hostregs;
>        regs->guestregs = regs;
>        regs->guest = 1;
>        regs->sie_mode = 1;
>        regs->opinterv = 0;
>        regs->cpustate = 1;
>    }
>
>
>    regs->cr[(32)].D = 0xFFFFFFFF;
>
>    for(i = 0; i < 16; i++)
>        regs->aea_ar[i] = 32;
>    regs->aea_ar[20] = 32;
>    regs->aea_ar[19] = 32;
>    regs->aea_ar[18] = 1;
>    regs->aea_ar[17] = 7;
>    regs->aea_ar[16] = 13;
>
>
>    set_opcode_pointers (regs);
>
>
>
>    s370_set_jump_pointers(regs, 0);
>
>
>    s390_set_jump_pointers(regs, 0);
>
>
>    z900_set_jump_pointers(regs, 0);
>
>
>    regs->configured = 1;
>
>    ptt_pthread_mutex_unlock((&sysblk.cpulock[cpu]),"cpu.c" ":" "1353");
>
>
>
>
>
>
>    return 0;
>}
>
>
>
>
>
>void *cpu_uninit (int cpu, REGS *regs)
>{
>    if (regs->host)
>    {
>        ptt_pthread_mutex_lock((&sysblk.cpulock[cpu]),"cpu.c" ":" "1371");
>        if (regs->guestregs)
>        {
>            cpu_uninit (cpu, regs->guestregs);
>            free (regs->guestregs);
>        }
>    }
>
>    pthread_cond_destroy((&regs->intcond));
>
>    if (regs->host)
>    {
>
>
>
>
>
>
>        sysblk.config_mask &= ~( (( CPU_BITMAP ) ( 1 ) ) << ( cpu ) );
>        sysblk.started_mask &= ~( (( CPU_BITMAP ) ( 1 ) ) << ( cpu ) );
>        sysblk.waiting_mask &= ~( (( CPU_BITMAP ) ( 1 ) ) << ( cpu ) );
>        sysblk.regs[cpu] = ((void *)0);
>        ptt_pthread_mutex_unlock((&sysblk.cpulock[cpu]),"cpu.c" ":" "1393");
>    }
>
>
>
>
>
>
>    return ((void *)0);
>}
># 1411 "cpu.c"
>void (__attribute__ (( regparm(1) )) s370_process_interrupt)(REGS *regs)
>{
>
>    if( ( (regs)->ints_state & (regs)->ints_mask & ( ( 1 << (23) ) | ( 1 << (22) ) | ( 1 << (21) ) | ( 1 << (20) ) | ( 1 << (19) ) | ( 1 << (16) ) ) ) )
>        regs->program_interrupt (regs, 0x0080);
>
>
>    do { REGS *_regs = (regs); if ((_regs)) (_regs)->hostregs->intwait = 1; ptt_pthread_mutex_lock((&sysblk.intlock),"cpu.c" ":" "1418"); if ((_regs)) { while (sysblk.syncing) { sysblk.sync_mask &= ~(_regs)->hostregs->cpubit; if (!sysblk.sync_mask) ptt_pthread_cond_signal((&sysblk.sync_cond),"cpu.c" ":" "1418"); ptt_pthread_cond_wait((&sysblk.sync_bc_cond),(&sysblk.intlock),"cpu.c" ":" "1418"); } (_regs)->hostregs->intwait = 0; sysblk.intowner = (_regs)->hostregs->cpuad; } else sysblk.intowner = 0xFFFE; } while (0);
>    do { (regs)->ints_state &= ~( 1 << (31) ); } while (0);
>    regs->tracing = (sysblk.inststep || sysblk.insttrace);
>
>
>    do { if ((regs)->aie) { (regs)->psw.ia.F.L.F = ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((0))) & (0x00FFFFFF)); (regs)->aie = ((void *)0); } } while (0);
>
>
>    if (__builtin_expect((regs->invalidate),0))
>        s370_invalidate_tlbe(regs, regs->invalidate_main);
>
>
>    if (__builtin_expect((regs->cpustate == 1),1))
>    {
>
>        if ( ( (regs)->ints_state & (regs)->ints_mask & ( ( 1 << (28) ) | ( 1 << (27) ) | ( 1 << (26) ) | ( 1 << (25) ) | ( 1 << (24) ) ) ) )
>        {
>            do { } while (0);
>            do { } while (0);
>            s370_perform_mck_interrupt (regs);
>        }
>
>
>        if ( ( (regs)->ints_state & (regs)->ints_mask & ( ( 1 << (15) ) | ( 1 << (14) ) | ( 1 << (13) ) | ( 1 << (12) ) | ( 1 << (11) ) | ( 1 << (10) ) | ( 1 << (9) ) | ( 1 << (8) ) | ( 1 << (7) ) | ( 1 << (6) ) | ( 1 << (5) ) | ( 1 << (4) ) ) ) )
>        {
>            do { } while (0);
>            do { } while (0);
>            s370_perform_external_interrupt (regs);
>        }
>
>
>        if (( sysblk.ints_state & ( 1 << (30) ) ))
>        {
>            if ( ( (regs)->ints_state & (regs)->ints_mask & ( ( 1 << (30) ) ) ) )
>            {
>                do { } while (0);
>                do { } while (0);
>                s370_perform_io_interrupt (regs);
>            }
>            else
>                do { int i; CPU_BITMAP mask = (sysblk.waiting_mask); for (i = 0; mask; i++) { if (mask & 1) { ptt_pthread_cond_signal((&sysblk.regs[i]->intcond),"cpu.c" ":" "1458"); break; } mask >>= 1; } } while (0);
>        }
>    }
>
>
>    if (__builtin_expect((regs->cpustate == 2),0))
>    {
>
>        regs->opinterv = 0;
>        regs->cpustate = 3;
>
>
>        if (!regs->configured)
>            longjmp(regs->exitjmp, (-1));
>
>
>        if (regs->sigpireset)
>        {
>            do { } while (0);
>            do { } while (0);
>            s370_initial_cpu_reset (regs);
>            do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1479"); } while (0);
>            longjmp(regs->progjmp, (-1));
>        }
>
>
>        if (regs->sigpreset)
>        {
>            do { } while (0);
>            do { } while (0);
>            s370_cpu_reset (regs);
>            do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1489"); } while (0);
>            longjmp(regs->progjmp, (-1));
>        }
>
>
>        if (( (regs)->ints_state & ( 1 << (3) ) ))
>        {
>            do { (regs)->ints_state &= ~( 1 << (3) ); } while (0);
>            s370_store_status (regs, 0);
>            logmsg (("HHCCP010I CPU%4.4X store status completed.\n"),
>                    regs->cpuad);
>
>
>
>
>
>
>
>        }
>    }
>
>
>    if ( ( (regs)->ints_state & ( 1 << (1) ) ) )
>    {
>        do { } while (0);
>        do { } while (0);
>        do { (regs)->ints_state &= ~( 1 << (1) ); } while (0);
>        s370_restart_interrupt (regs);
>    }
>
>
>    if (__builtin_expect((regs->cpustate == 3),0))
>    {
>        S64 saved_timer = cpu_timer(regs);
>        regs->ints_state = ( 1 << (0) );
>        sysblk.started_mask ^= regs->cpubit;
>        sysblk.intowner = 0xFFFF;
>
>
>        ptt_pthread_cond_wait((&regs->intcond),(&sysblk.intlock),"cpu.c" ":" "1528");
>
>
>        while (sysblk.syncing)
>            ptt_pthread_cond_wait((&sysblk.sync_bc_cond),(&sysblk.intlock),"cpu.c" ":" "1532");
>
>        sysblk.intowner = regs->cpuad;
>        sysblk.started_mask |= regs->cpubit;
>        regs->ints_state |= sysblk.ints_state;
>        set_cpu_timer(regs,saved_timer);
>
>        do { (regs)->ints_state |= ( 1 << (31) ); } while (0);
>
>
>        s370_purge_tlb (regs);
>
>
>
>
>
>        if(sysblk.arch_mode != regs->arch_mode)
>            longjmp(regs->archjmp,(-1));
>
>        do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1551"); } while (0);
>        longjmp(regs->progjmp, (-1));
>    }
>
>
>    if ((((&regs->psw)->states & ( 1 << (1) )) != 0))
>    {
>
>        regs->waittod = host_tod();
>
>
>
>        if( ( ((regs)->ints_mask & ( ( ( 1 << (28) ) | ( 1 << (27) ) | ( 1 << (26) ) | ( 1 << (25) ) | ( 1 << (24) ) ) | ( ( 1 << (15) ) | ( 1 << (14) ) | ( 1 << (13) ) | ( 1 << (12) ) | ( 1 << (11) ) | ( 1 << (10) ) | ( 1 << (9) ) | ( 1 << (8) ) | ( 1 << (7) ) | ( 1 << (6) ) | ( 1 << (5) ) | ( 1 << (4) ) ) | ( ( 1 << (30) ) ) )) == 0 ) )
>        {
>            logmsg (("HHCCP011I CPU%4.4X: Disabled wait state\n" "          ")
>                                   ,
>                    regs->cpuad);
>            display_psw (regs);
>            regs->cpustate = 2;
>            do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1570"); } while (0);
>            longjmp(regs->progjmp, (-1));
>        }
>
>
>        sysblk.intowner = 0xFFFF;
>        sysblk.waiting_mask |= regs->cpubit;
>
>
>        ptt_pthread_cond_wait((&regs->intcond),(&sysblk.intlock),"cpu.c" ":" "1579");
>
>
>        while (sysblk.syncing)
>            ptt_pthread_cond_wait((&sysblk.sync_bc_cond),(&sysblk.intlock),"cpu.c" ":" "1583");
>
>
>        sysblk.waiting_mask ^= regs->cpubit;
>        sysblk.intowner = regs->cpuad;
>
>
>
>        regs->waittime += host_tod() - regs->waittod;
>        regs->waittod = 0;
>
>        do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1594"); } while (0);
>        longjmp(regs->progjmp, (-1));
>    }
>
>
>    do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1599"); } while (0);
>    return;
>
>}
>
>
>
>
>REGS *s370_run_cpu (int cpu, REGS *oldregs)
>{
>BYTE *ip;
>REGS regs;
>
>    if (oldregs)
>    {
>        memcpy (&regs, oldregs, sizeof(REGS));
>        free (oldregs);
>        regs.hostregs = &regs;
>        if (regs.guestregs)
>            regs.guestregs->hostregs = &regs;
>        sysblk.regs[cpu] = &regs;
>        ptt_pthread_mutex_unlock((&sysblk.cpulock[cpu]),"cpu.c" ":" "1620");
>        logmsg (("HHCCP007I CPU%4.4X architecture mode set to %s\n"),
>                cpu, get_arch_mode_string(&regs));
>    }
>    else
>    {
>        memset (&regs, 0, sizeof(REGS));
>
>        if (cpu_init (cpu, &regs, ((void *)0)))
>            return ((void *)0);
>
>        logmsg (("HHCCP003I CPU%4.4X architecture mode %s\n"),
>                cpu, get_arch_mode_string(&regs));
>
>
>
>
>
>
>    }
>
>    regs.program_interrupt = &s370_program_interrupt;
>
>
>
>
>    regs.tracing = (sysblk.inststep || sysblk.insttrace);
>    regs.ints_state |= sysblk.ints_state;
>
>
>    if (_setjmp (regs.exitjmp))
>        return cpu_uninit(cpu, &regs);
>
>
>    _setjmp (regs.archjmp);
>
>
>    if(sysblk.arch_mode != regs.arch_mode)
>    {
>        do { if (pttclass & (0x0100)) ptt_pthread_trace(0x0100,"*SETARCH",(void *)(uintptr_t)(regs.arch_mode),(void *)(uintptr_t)(sysblk.arch_mode),"cpu.c" ":" "1659",(int)(cpu)); } while(0);
>        regs.arch_mode = sysblk.arch_mode;
>        oldregs = malloc (sizeof(REGS));
>        if (oldregs)
>        {
>            memcpy(oldregs, &regs, sizeof(REGS));
>            ptt_pthread_mutex_lock((&sysblk.cpulock[cpu]),"cpu.c" ":" "1665");
>        }
>        else
>        {
>            logmsg (("HHCCP080E CPU%4.4X malloc failed for archjmp regs: %s\n"),
>                    cpu, strerror((*__errno_location ())));
>            cpu_uninit (cpu, &regs);
>        }
>        return oldregs;
>    }
>
>    do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1676"); } while (0);
>
>
>    _setjmp (regs.progjmp);
>
>
>    regs.execflag = 0;
>
>    do {
>        if (( ((&regs))->ints_state & ((&regs))->ints_mask ))
>            s370_process_interrupt(&regs);
>
>        ip = __builtin_expect((( ( !((0)) && ((&regs))->ip < ((&regs))->aie ) || ( ((0)) && (((&regs))->et.F.L.F & (0x7FFFF800|0x01)) == ((&regs))->aiv.F.L.F && ((BYTE *)((uintptr_t)(((&regs)))->aip | (uintptr_t)((((&regs))->et.F.L.F) & 0x000007FF))) < ((&regs))->aie ) )),1) ? ((0) ? ((BYTE *)((uintptr_t)((&regs))->aip | (uintptr_t)(((&regs)->et.F.L.F) & 0x000007FF))) : (&regs)->ip) : s370_instfetch ((&regs), (0));
>        regs.instcount++;
>        do { ; ; (&regs)->s370_opcode_table[ip[0]]((ip), (&regs)); } while(0);
>
>        do {
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s370_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s370_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s370_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s370_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s370_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s370_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>
>            regs.instcount += 12;
>
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s370_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s370_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s370_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s370_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s370_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s370_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>        } while (!( ((&regs))->ints_state & ((&regs))->ints_mask ));
>    } while (1);
>
>
>    return ((void *)0);
>
>}
>
>
>
>
>void s370_process_trace(REGS *regs)
>{
>int shouldtrace = 0;
>int shouldstep = 0;
>
>
>    if (( sysblk.insttrace && ( (sysblk.traceaddr[0] == 0 && sysblk.traceaddr[1] == 0) || (sysblk.traceaddr[0] <= sysblk.traceaddr[1] && ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & (0x00FFFFFF)) >= sysblk.traceaddr[0] && ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & (0x00FFFFFF)) <= sysblk.traceaddr[1] ) || (sysblk.traceaddr[0] > sysblk.traceaddr[1] && ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & (0x00FFFFFF)) >= sysblk.traceaddr[1] && ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & (0x00FFFFFF)) <= sysblk.traceaddr[0] ) ) ))
>        shouldtrace = 1;
>
>
>    if (( sysblk.inststep && ( (sysblk.stepaddr[0] == 0 && sysblk.stepaddr[1] == 0) || (sysblk.stepaddr[0] <= sysblk.stepaddr[1] && ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & (0x00FFFFFF)) >= sysblk.stepaddr[0] && ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & (0x00FFFFFF)) <= sysblk.stepaddr[1] ) || (sysblk.stepaddr[0] > sysblk.stepaddr[1] && ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & (0x00FFFFFF)) >= sysblk.stepaddr[1] && ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & (0x00FFFFFF)) <= sysblk.stepaddr[0] ) ) ))
>        shouldstep = 1;
>
>
>    if (shouldtrace || shouldstep)
>    {
>        BYTE *ip = regs->ip < regs->aip ? regs->inst : regs->ip;
>        s370_display_inst (regs, ip);
>    }
>
>
>    if (shouldstep)
>    {
>        REGS *hostregs = regs->hostregs;
>        S64 saved_timer[2];
>
>        do { REGS *_regs = (hostregs); if ((_regs)) (_regs)->hostregs->intwait = 1; ptt_pthread_mutex_lock((&sysblk.intlock),"cpu.c" ":" "1745"); if ((_regs)) { while (sysblk.syncing) { sysblk.sync_mask &= ~(_regs)->hostregs->cpubit; if (!sysblk.sync_mask) ptt_pthread_cond_signal((&sysblk.sync_cond),"cpu.c" ":" "1745"); ptt_pthread_cond_wait((&sysblk.sync_bc_cond),(&sysblk.intlock),"cpu.c" ":" "1745"); } (_regs)->hostregs->intwait = 0; sysblk.intowner = (_regs)->hostregs->cpuad; } else sysblk.intowner = 0xFFFE; } while (0);
>
>        hostregs->waittod = host_tod();
>
>
>
>        saved_timer[0] = cpu_timer(regs);
>        saved_timer[1] = cpu_timer(hostregs);
>        hostregs->cpustate = 3;
>        sysblk.started_mask &= ~hostregs->cpubit;
>        hostregs->stepwait = 1;
>        sysblk.intowner = 0xFFFF;
>        while (hostregs->cpustate == 3)
>        {
>            ptt_pthread_cond_wait((&hostregs->intcond),(&sysblk.intlock),"cpu.c" ":" "1759");
>        }
>        sysblk.intowner = hostregs->cpuad;
>        hostregs->stepwait = 0;
>        sysblk.started_mask |= hostregs->cpubit;
>        set_cpu_timer(regs,saved_timer[0]);
>        set_cpu_timer(hostregs,saved_timer[1]);
>
>        hostregs->waittime += host_tod() - hostregs->waittod;
>        hostregs->waittod = 0;
>
>        do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1770"); } while (0);
>    }
>}
># 1791 "cpu.c"
>void s370_set_jump_pointers (REGS *regs, int jump)
>{
>
>
>
>
>    switch (jump) {
>
>
>    case 0xa7:
>jump_a7xx:
> __asm__ (
>        "movzbl 1(%%eax),%%ecx\n\t"
>        "jmp    *%c0(%%edx,%%ecx,4)"
>        : : "i" (__builtin_offsetof (REGS, s370_opcode_a7xx))
>        );
>        return;
>    case 0xb2:
>jump_b2xx:
> __asm__ (
>        "movzbl 1(%%eax),%%ecx\n\t"
>        "jmp    *%c0(%%edx,%%ecx,4)"
>        : : "i" (__builtin_offsetof (REGS, s370_opcode_b2xx))
>        );
>        return;
>    case 0xb9:
>jump_b9xx:
> __asm__ (
>        "movzbl 1(%%eax),%%ecx\n\t"
>        "jmp    *%c0(%%edx,%%ecx,4)"
>        : : "i" (__builtin_offsetof (REGS, s370_opcode_b9xx))
>        );
>        return;
># 1843 "cpu.c"
>jump_ebxx:
> __asm__ (
>        "movzbl 5(%%eax),%%ecx\n\t"
>        "jmp    *%c0(%%edx,%%ecx,4)"
>        : : "i" (__builtin_offsetof (REGS, s370_opcode_ebxx))
>        );
>        return;
>
>
>    }
>
>    regs->s370_opcode_table[0xa7] = &&jump_a7xx;
>    regs->s370_opcode_table[0xb2] = &&jump_b2xx;
>    regs->s370_opcode_table[0xb9] = &&jump_b9xx;
>
>
>
>
>    regs->s370_opcode_table[0xeb] = &&jump_ebxx;
>
>
>
>
>
>
>}
>
>
>
>
>
># 1 "cpu.c" 1
># 40 "cpu.c"
># 1 "hercules.h" 1
>
>
>
>
>
>
>
># 1 "./config.h" 1
># 9 "hercules.h" 2
># 47 "hercules.h"
># 1 "feature.h" 1
>
>
>
>
># 1 "./config.h" 1
># 6 "feature.h" 2
># 26 "feature.h"
># 1 "featall.h" 1
># 27 "feature.h" 2
>
>
>
>
># 1 "feat390.h" 1
># 32 "feature.h" 2
>
>
>
>
>
>
># 1 "featchk.h" 1
># 39 "feature.h" 2
># 48 "hercules.h" 2
>
>
>
>
>
># 1 "cpuint.h" 1
># 54 "hercules.h" 2
># 41 "cpu.c" 2
># 1 "opcode.h" 1
># 2736 "opcode.h"
>int s390_startio (REGS *regs, DEVBLK *dev, ORB *orb);
>void *s370_execute_ccw_chain (DEVBLK *dev);
>void *s390_execute_ccw_chain (DEVBLK *dev);
>void *z900_execute_ccw_chain (DEVBLK *dev);
>int stchan_id (REGS *regs, U16 chan);
>int testch (REGS *regs, U16 chan);
>int testio (REGS *regs, DEVBLK *dev, BYTE ibyte);
>int test_subchan (REGS *regs, DEVBLK *dev, IRB *irb);
>int cancel_subchan (REGS *regs, DEVBLK *dev);
>void clear_subchan (REGS *regs, DEVBLK *dev);
>int halt_subchan (REGS *regs, DEVBLK *dev);
>int haltio (REGS *regs, DEVBLK *dev, BYTE ibyte);
>int resume_subchan (REGS *regs, DEVBLK *dev);
>int s390_present_io_interrupt (REGS *regs, U32 *ioid,
>        U32 *ioparm, U32 *iointid, BYTE *csw);
>int s390_present_zone_io_interrupt (U32 *ioid, U32 *ioparm,
>                                              U32 *iointid, BYTE zone);
>void io_reset (void);
>int chp_reset(REGS *, BYTE chpid);
>void channelset_reset(REGS *regs);
> int device_attention (DEVBLK *dev, BYTE unitstat);
> int s390_device_attention (DEVBLK *dev, BYTE unitstat);
>
>
>
>
>
>
>void s370_store_psw (REGS *regs, BYTE *addr);
>int s370_load_psw (REGS *regs, BYTE *addr);
>void s370_process_trace (REGS *regs);
>
>
>int s390_load_psw (REGS *regs, BYTE *addr);
>void s390_store_psw (REGS *regs, BYTE *addr);
>void s390_process_trace (REGS *regs);
>
>
>int z900_load_psw (REGS *regs, BYTE *addr);
>void z900_store_psw (REGS *regs, BYTE *addr);
>void z900_process_trace (REGS *regs);
>
>
>int cpu_init (int cpu, REGS *regs, REGS *hostregs);
>void s390_perform_io_interrupt (REGS *regs);
>void s390_checkstop_config(void);
>
> void (__attribute__ (( regparm(2) )) s370_program_interrupt) (REGS *regs, int code);
>
>
> void (__attribute__ (( regparm(2) )) s390_program_interrupt) (REGS *regs, int code);
>
> void (__attribute__ (( regparm(2) )) s390_program_interrupt) (REGS *regs, int code);
>void *cpu_thread (int *cpu);
> void copy_psw (REGS *regs, BYTE *addr);
>void display_psw (REGS *regs);
>
>
>
>int s390_diag_devtype (int r1, int r2, REGS *regs);
>int s390_syncblk_io (int r1, int r2, REGS *regs);
>int s390_syncgen_io (int r1, int r2, REGS *regs);
>void s390_extid_call (int r1, int r2, REGS *regs);
>int s390_cpcmd_call (int r1, int r2, REGS *regs);
>void s390_pseudo_timer (U32 code, int r1, int r2, REGS *regs);
>void s390_access_reipl_data (int r1, int r2, REGS *regs);
>int s390_diag_ppagerel (int r1, int r2, REGS *regs);
>void s390_vm_info (int r1, int r2, REGS *regs);
>int s390_device_info (int r1, int r2, REGS *regs);
>
>
>
>int s390_vm_blockio (int r1, int r2, REGS *regs);
>
>
>
>void s390_load_real_address_proc (REGS *regs,
>    int r1, int b2, U32 effective_addr2);
>
>
>
>void packed_to_binary (BYTE *dec, int len, U64 *result,
>    int *ovf, int *dxf);
>void binary_to_packed (S64 bin, BYTE *result);
>
>
>
>void s390_diagnose_call (U32 effective_addr2, int b2, int r1, int r3,
>    REGS *regs);
>
>
>
>void s390_scpend_call (void);
>int s390_mssf_call (int r1, int r2, REGS *regs);
>void s390_diag204_call (int r1, int r2, REGS *regs);
>void s390_diag224_call (int r1, int r2, REGS *regs);
>
>
>
>void s390_perform_external_interrupt (REGS *regs);
>void s390_store_status (REGS *ssreg, U64 aaddr);
>void store_status (REGS *ssreg, U64 aaddr);
>
>
>
>int load_ipl (U16 lcss, U16 devnum, int cpu, int clear);
>int s390_load_ipl (U16 lcss, U16 devnum, int cpu, int clear);
>int system_reset (int cpu, int clear);
>int s390_system_reset (int cpu, int clear);
>int cpu_reset (REGS *regs);
>int s390_cpu_reset (REGS *regs);
>int initial_cpu_reset (REGS *regs);
>int s390_initial_cpu_reset (REGS *regs);
>int s390_common_load_begin (int cpu, int clear);
>int s390_common_load_finish (REGS *regs);
>void storage_clear(void);
>void xstorage_clear(void);
>
>
>
>void set_sce_dir (char *path);
>char *get_sce_dir ();
>int load_main (char *fname, U64 startloc);
>int s390_load_main (char *fname, U64 startloc);
>int load_hmc (char *fname, int cpu, int clear);
>int s390_load_hmc (char *fname, int cpu, int clear);
>void s390_sclp_scedio_request (SCCB_HEADER *);
>void s390_sclp_scedio_event (SCCB_HEADER *);
>
>
>
>int s390_present_mck_interrupt (REGS *regs, U64 *mcic, U32 *xdmg,
>    U64 *fsta);
>U32 channel_report (REGS *);
>void machine_check_crwpend (void);
>void s390_sync_mck_interrupt (REGS *regs);
>void sigabend_handler (int signo);
>
>
>
>extern void copy_opcode_tables ();
>void set_opcode_pointers (REGS *regs);
>
>
>
>void s390_display_inst (REGS *regs, BYTE *inst);
>void display_inst (REGS *regs, BYTE *inst);
>
>
>
>void s390_sie_exit (REGS *regs, int code);
>void s390_diagnose_002 (REGS *regs, int r1, int r3);
>
>
>
>void s390_trap_x (int trap_is_trap4, REGS *regs, U32 trap_operand);
>void s390_form_stack_entry (BYTE etype, U32 retna, U32 calla,
>    U32 csi, U32 pcnum, REGS *regs);
>U32 s390_locate_stack_entry (int prinst, LSED *lsedptr,
>    REGS *regs);
>void s390_stack_modify (U32 lsea, U32 m1, U32 m2, REGS *regs);
>void s390_stack_extract (U32 lsea, int r1, int code, REGS *regs);
>void s390_unstack_registers (int gtype, U32 lsea, int r1,
>    int r2, REGS *regs);
>int s390_program_return_unstack (REGS *regs, U64 *lsedap, int *rc);
>
>
>
>U32 s390_trace_br (int amode, U32 ia, REGS *regs);
>
>U32 s390_trace_br (int amode, U32 ia, REGS *regs);
>
>U32 s390_trace_bsg (U32 alet, U32 ia, REGS *regs);
>U32 s390_trace_ssar (int ssair, U16 sasn, REGS *regs);
>U32 s390_trace_pc (U32 pcea, REGS *regs);
>U32 s390_trace_pr (REGS *newregs, REGS *regs);
>U32 s390_trace_pt (int pti, U16 pasn, U32 gpr2, REGS *regs);
>U32 s390_trace_tr (int r1, int r3, U32 op, REGS *regs);
>U32 s390_trace_tg (int r1, int r3, U32 op, REGS *regs);
>U32 s390_trace_ms (int br_ind, U32 ia, REGS *regs);
>
>
>
>int s390_plo_cl (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s390_plo_clg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s390_plo_clgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s390_plo_clx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s390_plo_cs (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s390_plo_csg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s390_plo_csgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s390_plo_csx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s390_plo_dcs (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s390_plo_dcsg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s390_plo_dcsgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s390_plo_dcsx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s390_plo_csst (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s390_plo_csstg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s390_plo_csstgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s390_plo_csstx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s390_plo_csdst (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s390_plo_csdstg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s390_plo_csdstgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s390_plo_csdstx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s390_plo_cstst (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s390_plo_cststg (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s390_plo_cststgr (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>int s390_plo_cststx (int r1, int r3, U32 effective_addr2, int b2,
>                            U32 effective_addr4, int b4, REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s390_execute_01xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_execute_a4xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_execute_a5xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_execute_a6xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_execute_a7xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_execute_b2xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_execute_b3xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_execute_b9xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_execute_c0xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_execute_e3xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_execute_e4xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_execute_e5xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_execute_ebxx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_execute_ecxx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_execute_edxx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_operation_exception) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_dummy_instruction) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s390_fix_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_svc_assist) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_obtain_local_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_release_local_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_obtain_cms_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_release_cms_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_trace_svc_interruption) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_trace_program_interruption) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_trace_initial_srb_dispatch) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_trace_io_interruption) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_trace_task_dispatch) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_trace_svc_return) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s390_compression_call) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s390_cipher_message_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_cipher_message_with_chaining_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compute_intermediate_message_digest_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compute_last_message_digest_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compute_message_authentication_code_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_perform_cryptographic_key_management_operation_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_cipher_message_with_cipher_feedback_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_cipher_message_with_counter_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_cipher_message_with_output_feedback_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_perform_cryptographic_computation_r) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s390_branch_and_set_authority) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_in_subspace_group) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_and_stack) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_and_swap_and_purge) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_diagnose) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_extract_primary_asn) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_extract_primary_asn_and_instance) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_extract_secondary_asn) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_extract_secondary_asn_and_instance) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_extract_stacked_registers) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_extract_stacked_state) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_insert_address_space_control) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_insert_psw_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_insert_storage_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_insert_storage_key_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_insert_virtual_storage_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_invalidate_page_table_entry) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_address_space_parameters) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_control) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_program_status_word) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_real_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_using_real_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_lock_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_modify_stacked_state) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_move_to_primary) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_move_to_secondary) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_move_with_destination_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_move_with_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_move_with_optional_specifications) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_move_with_source_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_program_call) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_program_return) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_program_transfer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_program_transfer_with_instance) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_purge_accesslist_lookaside_buffer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_purge_translation_lookaside_buffer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_reset_reference_bit) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_reset_reference_bit_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_address_space_control) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_address_space_control_fast) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_clock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_clock_comparator) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_clock_programmable_field) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_cpu_timer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_prefix) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_psw_key_from_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_secondary_asn) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_secondary_asn_with_instance) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_storage_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_storage_key_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_system_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_signal_processor) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_clock_comparator) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_control) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_cpu_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_cpu_id) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_cpu_timer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_prefix) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_system_information) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_then_and_system_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_then_or_system_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_using_real_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_access) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_block) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_protection) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_trace) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s390_add_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_edit_x_edit_and_mark) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_shift_and_round_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_zero_and_add) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_decimal) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s390_inter_user_communication_vehicle) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s390_start_interpretive_execution) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_zone_parameter) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_zone_parameter) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_pending_zone_interrupt) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s390_signal_adapter) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s390_load_positive_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_negative_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_and_test_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_complement_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_halve_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_rounded_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_float_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_unnormal_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_unnormal_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_positive_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_negative_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_and_test_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_complement_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_halve_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_rounded_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_float_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_unnormal_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_unnormal_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_float_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_unnormal_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_unnormal_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_float_short_to_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_unnormal_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_unnormal_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_squareroot_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_squareroot_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_lengthened_float_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_lengthened_float_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_lengthened_float_short_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_squareroot_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_positive_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_negative_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_and_test_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_complement_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_rounded_float_ext_to_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_fp_int_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_fp_int_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_fp_int_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_fixed_to_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_fixed_to_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_fixed_to_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_fix64_to_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_fix64_to_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_fix64_to_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_float_short_to_fixed_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_float_long_to_fixed_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_float_ext_to_fixed_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_float_short_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_float_long_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_float_ext_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_lengthened_float_short_to_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_lengthened_float_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_lengthened_float_short_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_squareroot_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_squareroot_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_zero_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_zero_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_zero_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_add_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_add_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_add_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_add_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_subtract_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_subtract_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_subtract_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_subtract_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_unnormal_float_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_unnormal_float_long_to_ext_low_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_unnormal_float_long_to_ext_high_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_add_unnormal_float_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_add_unnormal_float_long_to_ext_low_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_add_unnormal_float_long_to_ext_high_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_unnormal_float_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_unnormal_float_long_to_ext_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_unnormal_float_long_to_ext_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_add_unnormal_float_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_add_unnormal_float_long_to_ext_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_add_unnormal_float_long_to_ext_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_float_long_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_float_short_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_float_long_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_float_short_y) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s390_add_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_and_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_and) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_and_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_and_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_and_link_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_and_link) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_and_save_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_and_save) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_and_save_and_set_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_and_set_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_on_condition_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_on_condition) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_on_count_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_on_count) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_on_index_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_on_index_low_or_equal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_relative_on_condition) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_relative_and_save) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_relative_on_count) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_relative_on_index_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_relative_on_index_low_or_equal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_checksum) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_and_form_codeword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_and_swap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_double_and_swap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_and_swap_and_store) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_characters_under_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_character_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_long_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_string) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_until_substring_equal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_utf16_to_utf8) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_utf16_to_utf32) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_utf32_to_utf16) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_utf32_to_utf8) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_utf8_to_utf16) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_utf8_to_utf32) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_to_binary) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_to_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_copy_access) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_exclusive_or_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_exclusive_or) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_exclusive_or_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_exclusive_or_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_execute) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_execute_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_extract_access_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_insert_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_insert_characters_under_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_insert_program_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_access_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_address_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_and_test_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_complement_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_negative_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_positive_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_monitor_call) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_move_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_move_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_move_inverse) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_move_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_move_long_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_move_numerics) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_move_string) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_move_with_offset) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_move_zones) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_single_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_single) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s390_or_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_or) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_or_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_or_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_perform_locked_operation) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_pack) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_search_string) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_search_string_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_access_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_program_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_shift_left_double) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_shift_left_double_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_shift_left_single) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_shift_left_single_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_shift_right_double) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_shift_right_double_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_shift_right_single) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_shift_right_single_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_access_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_characters_under_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_clock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_clock_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_clock_fast) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_supervisor_call) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_and_set) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_under_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_under_mask_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_under_mask_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_translate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_translate_and_test) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_translate_and_test_reverse) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_translate_and_test_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_translate_and_test_reverse_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_translate_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_unpack) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_update_tree) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s390_add_immediate_long_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_immediate_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_logical_with_signed_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_logical_with_signed_immediate_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_and_branch_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_and_branch_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_and_branch_relative_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_and_branch_relative_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_and_trap_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_and_trap_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_halfword_immediate_halfword_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_halfword_immediate_long_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_halfword_immediate_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_halfword_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_halfword_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_halfword_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_immediate_and_branch) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_immediate_and_branch_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_immediate_and_branch_relative) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_immediate_and_branch_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_immediate_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_immediate_and_trap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_and_branch_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_and_branch_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_and_branch_relative_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_and_branch_relative_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_and_trap_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_and_trap_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_immediate_and_branch) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_immediate_and_branch_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_immediate_and_branch_relative) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_immediate_and_branch_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_immediate_and_trap_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_immediate_and_trap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_immediate_fullword_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_immediate_halfword_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_immediate_long_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_relative_long_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_relative_long_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_relative_long_long_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_relative_long_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_extract_cache_attribute) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_address_extended_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_and_test_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_halfword_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_halfword_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_halfword_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_halfword_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_relative_long_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_relative_long_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_move_fullword_from_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_move_halfword_from_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_move_long_from_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_single_immediate_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_single_immediate_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_prefetch_data) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_prefetch_data_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_rotate_then_and_selected_bits_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_rotate_then_exclusive_or_selected_bits_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_rotate_then_insert_selected_bits_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_rotate_then_or_selected_bits_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_halfword_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_relative_long_long) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s390_add_high_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_high_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_high_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_logical_high_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_logical_high_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_logical_with_signed_immediate_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_logical_with_signed_immediate_high_n) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_relative_on_count_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_high_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_high_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_byte_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_fullword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_halfword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_character_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_halfword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_rotate_then_insert_selected_bits_high_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_rotate_then_insert_selected_bits_low_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_character_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_fullword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_halfword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_high_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_high_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_logical_high_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_logical_high_high_low_register) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s390_load_and_add) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_and_add_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_and_add_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_and_add_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_and_and) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_and_and_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_and_exclusive_or) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_and_exclusive_or_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_and_or) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_and_or_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_pair_disjoint) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_pair_disjoint_long) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s390_load_on_condition_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_on_condition_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_on_condition) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_on_condition_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_on_condition) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_on_condition_long) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s390_add_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_distinct_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_distinct_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_logical_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_logical_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_logical_distinct_signed_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_logical_distinct_long_signed_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_and_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_and_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_exclusive_or_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_exclusive_or_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_or_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_or_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_shift_right_single_distinct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_shift_left_single_distinct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_shift_right_single_logical_distinct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_shift_left_single_logical_distinct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_logical_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_logical_distinct_long_register) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s390_population_count) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s390_load_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_long_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_fullword_high_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_long_fullword_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_long_thirtyone_and_trap) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s390_compare_logical_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_and_trap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_rotate_then_insert_selected_bits_long_reg_n) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) s390_branch_prediction_preload) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_prediction_relative_preload) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_next_instruction_access_intent) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s390_clear_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_halt_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_modify_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_resume_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_address_limit) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_channel_monitor) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_reset_channel_path) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_start_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_cancel_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_channel_path_status) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_channel_report_word) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_pending_interruption) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_start_io) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_io) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_halt_io) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_channel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_channel_id) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_connect_channel_set) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_disconnect_channel_set) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s390_service_call) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s390_channel_subsystem_call) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s390_page_in) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_page_out) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_move_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_invalidate_expanded_storage_block_entry) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s390_v_test_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_complement_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_count_left_zeros_in_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_count_ones_in_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_extract_vct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_extract_vector_modes) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_restore_vr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_save_changed_vr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_save_vr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_load_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_load_vmr_complement) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_store_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_and_to_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_or_to_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_exclusive_or_to_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_save_vsr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_save_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_restore_vsr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_restore_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_load_vct_from_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_clear_vr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_set_vector_mask_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_load_vix_from_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_store_vector_parameters) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_save_vac) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_v_restore_vac) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s390_store_fpc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_fpc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_fpc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_extract_fpc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_bfp_rounding_mode_2bit) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_bfp_rounding_mode_3bit) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_trap2) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_trap4) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_resume_program) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_trace_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_to_binary_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_to_decimal_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_logical_carry_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_logical_borrow_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_logical_carry_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_logical_borrow_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_logical_carry_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_logical_borrow_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_logical_carry) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_logical_borrow) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_single_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_single_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_single_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_single_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_long_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_long_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_pair_to_quadword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_pair_from_quadword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_extract_stacked_registers_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_extract_psw) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_extract_and_set_extended_authority) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_address_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_perform_frame_management_function) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_perform_timing_facility_function) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_perform_topology_function) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_reset_reference_bits_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_facility_list) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_facility_list_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_and_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_or_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_exclusive_or_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_and_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_or_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_exclusive_or_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_logical_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_logical_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_control_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_control_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_multiple_disjoint) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_multiple_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_multiple_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_multiple_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_multiple_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_using_real_address_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_using_real_address_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_addressing_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_addressing_mode_24) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_addressing_mode_31) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_addressing_mode_64) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_program_status_word_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_real_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_single_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_single_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_single_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_single_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_rotate_left_single_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_rotate_left_single_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_shift_right_single_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_shift_left_single_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_shift_right_single_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_shift_left_single_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_long_thirtyone_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_under_mask_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_under_mask_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_relative_on_count_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_positive_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_negative_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_and_test_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_complement_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_real_address_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_logical_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_logical_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_on_count_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_on_count_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_and_swap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_double_and_swap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_on_index_high_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_on_index_low_or_equal_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_relative_on_index_high_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_relative_on_index_low_or_equal_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_characters_under_mask_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_characters_under_mask_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_insert_characters_under_mask_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_relative_on_condition_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_branch_relative_and_save_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_positive_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_negative_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_and_test_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_complement_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_long_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_long_thirtyone) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_insert_immediate_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_insert_immediate_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_insert_immediate_low_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_insert_immediate_low_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_and_immediate_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_and_immediate_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_and_immediate_low_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_and_immediate_low_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_or_immediate_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_or_immediate_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_or_immediate_low_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_or_immediate_low_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_immediate_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_immediate_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_immediate_low_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_immediate_low_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_reversed_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_reversed_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_reversed_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_reversed) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_reversed_half) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_reversed_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_reversed) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_reversed_half) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_pack_ascii) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_pack_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_unpack_ascii) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_unpack_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_translate_two_to_two) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_translate_two_to_one) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_translate_one_to_two) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_translate_one_to_one) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_move_long_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_long_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_logical_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_and_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_and_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_and_swap_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_double_and_swap_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_characters_under_mask_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_to_binary_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_to_decimal_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_exclusive_or_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_exclusive_or_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_insert_character_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_insert_characters_under_mask_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_access_multiple_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_address_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_byte) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_byte_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_multiple_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_real_address_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_move_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_single_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_or_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_or_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_access_multiple_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_character_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_characters_under_mask_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_store_multiple_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_logical_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_under_mask_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_and_swap_and_purge_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_invalidate_dat_table_entry) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_and_replace_dat_table_entry) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_page_table_entry_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_logical_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_logical_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_and_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_and_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_logical_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_exclusive_or_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_exclusive_or_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_insert_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_insert_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_or_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_or_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_logical_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_logical_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_and_test) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_and_test_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_byte_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_long_byte_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_halfword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_long_halfword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_character_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_long_character_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_halfword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_logical_long_halfword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_find_leftmost_one_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_extract_cpu_time) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_program_parameter) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s390_ecpsvm_basic_freex) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_ecpsvm_basic_fretx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_ecpsvm_lock_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_ecpsvm_unlock_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_ecpsvm_decode_next_ccw) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_ecpsvm_free_ccwstor) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_ecpsvm_locate_vblock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_ecpsvm_disp1) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_ecpsvm_tpage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_ecpsvm_tpage_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_ecpsvm_inval_segtab) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_ecpsvm_inval_ptable) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_ecpsvm_decode_first_ccw) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_ecpsvm_dispatch_main) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_ecpsvm_locate_rblock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_ecpsvm_comm_ccwproc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_ecpsvm_unxlate_ccw) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_ecpsvm_disp2) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_ecpsvm_store_level) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_ecpsvm_loc_chgshrpg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_ecpsvm_extended_freex) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_ecpsvm_extended_fretx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_ecpsvm_prefmach_assist) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s390_convert_bfp_long_to_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_bfp_short_to_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_float_long_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_float_long_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_and_signal_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_and_signal_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_and_signal_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_and_signal_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_and_signal_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_fix32_to_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_fix32_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_fix32_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_u32_to_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_u32_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_u32_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_fix64_to_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_fix64_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_fix64_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_u64_to_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_u64_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_u64_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_bfp_ext_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_bfp_long_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_bfp_short_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_bfp_ext_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_bfp_long_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_bfp_short_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_bfp_ext_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_bfp_long_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_bfp_short_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_bfp_ext_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_bfp_long_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_bfp_short_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_integer_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_integer_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_and_test_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_and_test_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_and_test_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_fp_int_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_fp_int_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_fp_int_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_lengthened_bfp_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_lengthened_bfp_short_to_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_lengthened_bfp_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_lengthened_bfp_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_lengthened_bfp_short_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_lengthened_bfp_short_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_negative_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_negative_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_negative_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_complement_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_complement_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_complement_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_positive_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_positive_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_positive_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_rounded_bfp_long_to_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_rounded_bfp_ext_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_rounded_bfp_ext_to_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_bfp_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_bfp_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_bfp_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_bfp_short_to_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_add_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_add_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_add_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_add_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_subtract_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_subtract_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_subtract_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_subtract_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_squareroot_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_squareroot_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_squareroot_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_squareroot_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_squareroot_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_data_class_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_data_class_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_data_class_bfp_ext) (BYTE inst[], REGS *regs);
>
>
>void (__attribute__ (( regparm(2) )) s390_copy_sign_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_complement_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_fpr_from_gr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_gr_from_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_negative_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_positive_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_dfp_rounding_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_fpc_and_signal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_set_fpc_and_signal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_add_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_and_signal_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_and_signal_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_exponent_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_compare_exponent_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_fix32_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_fix32_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_u32_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_u32_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_fix64_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_fix64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_u64_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_u64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_sbcd128_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_sbcd64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_ubcd128_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_ubcd64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_zoned_to_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_zoned_to_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_dfp_ext_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_dfp_long_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_dfp_ext_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_dfp_long_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_dfp_ext_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_dfp_long_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_dfp_ext_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_dfp_long_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_dfp_ext_to_sbcd128_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_dfp_long_to_sbcd64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_dfp_ext_to_ubcd128_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_dfp_long_to_ubcd64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_dfp_ext_to_zoned) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_convert_dfp_long_to_zoned) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_divide_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_extract_biased_exponent_dfp_ext_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_extract_biased_exponent_dfp_long_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_extract_significance_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_extract_significance_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_insert_biased_exponent_fix64_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_insert_biased_exponent_fix64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_and_test_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_and_test_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_fp_int_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_fp_int_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_lengthened_dfp_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_lengthened_dfp_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_rounded_dfp_ext_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_load_rounded_dfp_long_to_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_multiply_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_quantize_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_quantize_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_reround_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_reround_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_shift_coefficient_left_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_shift_coefficient_left_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_shift_coefficient_right_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_shift_coefficient_right_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_subtract_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_data_class_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_data_class_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_data_class_dfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_data_group_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_data_group_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_test_data_group_dfp_short) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s390_perform_floating_point_operation) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) s390_perform_processor_assist) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_extract_transaction_nesting_depth) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_nontransactional_store_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_transaction_abort) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_transaction_begin) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_transaction_begin_constrained) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) s390_transaction_end) (BYTE inst[], REGS *regs);
># 42 "cpu.c" 2
># 1 "inline.h" 1
># 16 "inline.h"
>static inline U16 s390_translate_asn (U16 asn, REGS *regs,
>        U32 *asteo, U32 aste[]);
>static inline int s390_authorize_asn (U16 ax, U32 aste[],
>        int atemask, REGS *regs);
>
>
>static inline U16 s390_translate_alet (U32 alet, U16 eax,
>        int acctype, REGS *regs, U32 *asteo, U32 aste[]);
>static inline void s390_purge_alb_all ();
>static inline void s390_purge_alb (REGS *regs);
>
>static inline int s390_translate_addr (U32 vaddr, int arn,
>        REGS *regs, int acctype);
>static inline void s390_purge_tlb_all ();
>static inline void s390_purge_tlb (REGS *regs);
>static inline void s390_purge_tlbe_all (U64 pfra);
>static inline void s390_purge_tlbe (REGS *regs, U64 pfra);
>static inline void s390_invalidate_tlb (REGS *regs, BYTE mask);
>
>static inline void z900_invalidate_tlb (REGS *regs, BYTE mask);
>
>static inline void s390_invalidate_tlbe (REGS *regs, BYTE *main);
>static inline void s390_invalidate_pte (BYTE ibyte, U64 op1,
>        U32 op2, REGS *regs);
>static inline BYTE *s390_logical_to_main (U32 addr, int arn,
>        REGS *regs, int acctype, BYTE akey);
>
>
>static inline BYTE *s390_logical_to_main (U32 addr, int arn, REGS *regs,
>        int acctype, BYTE akey);
>static inline int s390_translate_addr (U32 vaddr, int arn, REGS *regs,
>        int acctype);
>
>
>
>static inline BYTE *z900_logical_to_main (U64 addr, int arn, REGS *regs,
>        int acctype, BYTE akey);
>static inline int z900_translate_addr (U64 vaddr, int arn, REGS *regs,
>        int acctype);
>
>
>static inline void s390_vstorec (void *src, BYTE len,
>        U32 addr, int arn, REGS *regs);
>static inline void s390_vstoreb (BYTE value, U32 addr,
>        int arn, REGS *regs);
>static inline void s390_vstore2 (U16 value, U32 addr, int arn,
>        REGS *regs);
>static inline void s390_vstore4 (U32 value, U32 addr, int arn,
>        REGS *regs);
>static inline void s390_vstore8 (U64 value, U32 addr, int arn,
>        REGS *regs);
>static inline void s390_vfetchc (void *dest, BYTE len,
>        U32 addr, int arn, REGS *regs);
>static inline BYTE s390_vfetchb (U32 addr, int arn,
>        REGS *regs);
>static inline U16 s390_vfetch2 (U32 addr, int arn,
>        REGS *regs);
>static inline U32 s390_vfetch4 (U32 addr, int arn,
>        REGS *regs);
>static inline U64 s390_vfetch8 (U32 addr, int arn,
>        REGS *regs);
>static inline void s390_move_chars (U32 addr1, int arn1,
>      BYTE key1, U32 addr2, int arn2, BYTE key2, int len, REGS *regs);
>static inline void s390_validate_operand (U32 addr, int arn,
>        int len, int acctype, REGS *regs);
>static inline BYTE * s390_instfetch (REGS *regs, int exec);
>
>
>static inline BYTE * s370_instfetch (REGS *regs, int exec);
>
>
>
>static inline BYTE * s390_instfetch (REGS *regs, int exec);
># 323 "inline.h"
>static inline int s390_is_fetch_protected (U32 addr, BYTE skey,
>                    BYTE akey, REGS *regs)
>{
>    ((addr)=(addr));
>    ((regs)=(regs));
>
>
>
>
>
>    if (__builtin_expect((akey == 0 || akey == (skey & 0xF0) || !(skey & 0x08)),1)
>
>                               )
>    return 0;
>
>
>
>
>    if (addr < 2048
>    && (regs->cr[(0)].F.L.F & 0x02000000)
>    && regs->dat.private == 0)
>    return 0;
>
>
>
>
>
>
>    if ((skey & 0xF0) == 0x90
>    && (regs->cr[(0)].F.L.F & 0x01000000))
>    return 0;
>
>
>
>    return 1;
>
>}
># 371 "inline.h"
>static inline int s390_is_low_address_protected (U32 addr,
>                                              REGS *regs)
>{
>
>
>
>
>
>
>
>    if (addr > 511)
>
>        return 0;
>
>
>
>    if ((regs->cr[(0)].F.L.F & 0x10000000) == 0)
>        return 0;
>
>
>
>
>    if (regs->sie_active)
>        return 0;
>
>
>
>
>    if (regs->dat.private)
>        return 0;
>
>
>    return 1;
>
>}
># 421 "inline.h"
>static inline int s390_is_store_protected (U32 addr, BYTE skey,
>               BYTE akey, REGS *regs)
>{
>
>
>
>
>    if (s390_is_low_address_protected (addr, regs))
>        return 1;
>
>
>
>
>    if (regs->dat.protect)
>        return 1;
>
>    if(__builtin_expect(((regs)->sie_mode),0) && regs->hostregs->dat.protect)
>        return 1;
>
>
>
>
>    if (akey == 0)
>        return 0;
>
>
>
>
>
>    if ((skey & 0xF0) == 0x90
>        && (regs->cr[(0)].F.L.F & 0x01000000))
>        return 0;
>
>
>
>
>    if (akey != (skey & 0xF0))
>        return 1;
>
>
>    return 0;
>
>}
># 475 "inline.h"
>static inline BYTE *s390_fetch_main_absolute (U64 addr,
>                                REGS *regs)
>
>{
>
>
>
>
>
>    do { if(__builtin_expect((((regs))->sie_mode),0) && !(regs)->sie_pref) *(&addr) = ( ((((regs)->hostregs)->arch_mode == 1) ? s390_logical_to_main(((regs)->sie_mso + *(&addr)), (18), ((regs)->hostregs), ((0x0004)), (0)) : z900_logical_to_main(((regs)->sie_mso + *(&addr)), (18), ((regs)->hostregs), ((0x0004)), (0))), ((regs)->hostregs)->dat.aaddr ); } while(0);
>
>
>    (regs)->storkeys[(addr)>>11] |= 0x04;
>
>
>    return (regs->mainstor + addr);
>
>}
># 503 "inline.h"
>static inline U64 s390_fetch_doubleword_absolute (U64 addr,
>                                REGS *regs)
>{
>
>
>
>
>
>
>    return __bswap_64 (*(U64 *)s390_fetch_main_absolute((addr), (regs)));
>
>
>
>}
># 527 "inline.h"
>static inline U32 s390_fetch_fullword_absolute (U64 addr,
>                                REGS *regs)
>{
>    return __bswap_32 (fetch_fw_noswap((s390_fetch_main_absolute((addr), (regs)))));
>}
># 542 "inline.h"
>static inline U16 s390_fetch_halfword_absolute (U64 addr,
>                                REGS *regs)
>{
>    return (__extension__ ({ unsigned short int __v, __x = (unsigned short int) (fetch_hw_noswap((s390_fetch_main_absolute((addr), (regs))))); if (__builtin_constant_p (__x)) __v = ((unsigned short int) ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8))); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; }));
>}
># 555 "inline.h"
>static inline void s390_store_doubleword_absolute (U64 value,
>                          U64 addr, REGS *regs)
>{
>
>
>
>
>
>    do { if(__builtin_expect((((regs))->sie_mode),0) && !(regs)->sie_pref) *(&addr) = ( ((((regs)->hostregs)->arch_mode == 1) ? s390_logical_to_main(((regs)->sie_mso + *(&addr)), (18), ((regs)->hostregs), ((0x0002)), (0)) : z900_logical_to_main(((regs)->sie_mso + *(&addr)), (18), ((regs)->hostregs), ((0x0002)), (0))), ((regs)->hostregs)->dat.aaddr ); } while(0);
>
>
>    (regs)->storkeys[(addr)>>11] |= (0x04 | 0x02);
>
>
>    store_dw_i686_noswap((regs->mainstor + addr),__bswap_64 ((value)));
>
>}
># 580 "inline.h"
>static inline void s390_store_fullword_absolute (U32 value,
>                          U64 addr, REGS *regs)
>{
>
>
>
>
>
>    do { if(__builtin_expect((((regs))->sie_mode),0) && !(regs)->sie_pref) *(&addr) = ( ((((regs)->hostregs)->arch_mode == 1) ? s390_logical_to_main(((regs)->sie_mso + *(&addr)), (18), ((regs)->hostregs), ((0x0002)), (0)) : z900_logical_to_main(((regs)->sie_mso + *(&addr)), (18), ((regs)->hostregs), ((0x0002)), (0))), ((regs)->hostregs)->dat.aaddr ); } while(0);
>
>
>    (regs)->storkeys[(addr)>>11] |= (0x04 | 0x02);
>
>
>    store_fw_noswap((regs->mainstor + addr), __bswap_32 ((value)));
>
>}
># 637 "inline.h"
>static inline U64 s390_subspace_replace (U64 std, U32 asteo,
>                        U16 *xcode, REGS *regs)
>{
>U32 ducto;
>U32 duct0;
>U32 duct1;
>U32 duct3;
>U32 ssasteo;
>U32 ssaste[16];
>BYTE *p;
>
>
>    if (xcode != ((void *)0)) *xcode = 0;
>
>
>
>
>    if (!((regs)->cr[(0)].F.L.F & 0x00010000)
>        || (std & 0x00000200) == 0)
>        return std;
>
>
>    ducto = regs->cr[(2)].F.L.F & 0x7FFFFFC0;
>    ducto = ( ((U32)(ducto) & 0x7FFFF000) == 0 || ((U32)(ducto) & 0x7FFFF000) == (regs->px.F.L.F) ? (U32)(ducto) ^ (regs->px.F.L.F) : (ducto) );
>
>
>    if (ducto > regs->mainlim)
>        regs->program_interrupt (regs, 0x0005);
>
>
>
>    p = s390_fetch_main_absolute((ducto), (regs));
>    duct0 = __bswap_32 (fetch_fw_noswap((p)));
>    duct1 = __bswap_32 (fetch_fw_noswap((p+4)));
>    duct3 = __bswap_32 (fetch_fw_noswap((p+12)));
>
>
>
>
>    if ((duct1 & 0x80000000) == 0
>        || asteo != (duct0 & 0x7FFFFFC0))
>        return std;
>
>
>    ssasteo = duct1 & 0x7FFFFFC0;
>    ssasteo = ( ((U32)(ssasteo) & 0x7FFFF000) == 0 || ((U32)(ssasteo) & 0x7FFFF000) == (regs->px.F.L.F) ? (U32)(ssasteo) ^ (regs->px.F.L.F) : (ssasteo) );
>
>
>    if (ssasteo > regs->mainlim)
>        regs->program_interrupt (regs, 0x0005);
>
>
>
>    p = s390_fetch_main_absolute((ssasteo), (regs));
>    ssaste[0] = __bswap_32 (fetch_fw_noswap((p)));
>    ssaste[2] = __bswap_32 (fetch_fw_noswap((p+8)));
>
>
>
>    ssaste[5] = __bswap_32 (fetch_fw_noswap((p+20)));
>
>
>    if (ssaste[0] & 0x80000000)
>    {
>        regs->excarid = 0;
>        if (xcode == ((void *)0))
>            regs->program_interrupt (regs, 0x002B);
>        else
>            *xcode = 0x002B;
>        return 0;
>    }
>
>
>
>    if ((ssaste[5] & 0xFFFFFFFF) != (duct3 & 0xFFFFFFFF))
>    {
>        regs->excarid = 0;
>        if (xcode == ((void *)0))
>            regs->program_interrupt (regs, 0x002C);
>        else
>            *xcode = 0x002C;
>        return 0;
>    }
>
>
>
>
>    std &= (0x80000000 | 0x00000080);
>    std |= (((ssaste)[2])
>                & ~((U64)(0x80000000 | 0x00000080)));
>
>
>    return std;
>
>}
>
>
># 1 "dat.h" 1
># 53 "dat.h"
>static inline U16 s390_translate_asn (U16 asn, REGS *regs,
>                                                U32 *asteo, U32 aste[])
>{
>U32 afte_addr;
>U32 afte;
>U32 aste_addr;
>BYTE *aste_main;
>int code;
>int numwords;
>int i;
>
>
>    afte_addr = (regs->cr[(14)].F.L.F & 0x0007FFFF) << 12;
>    afte_addr += (asn & 0xFFC0) >> 4;
>
>
>    if (afte_addr > regs->mainlim)
>        goto asn_addr_excp;
>
>
>
>    afte_addr = ( ((U32)(afte_addr) & 0x7FFFF000) == 0 || ((U32)(afte_addr) & 0x7FFFF000) == (regs->px.F.L.F) ? (U32)(afte_addr) ^ (regs->px.F.L.F) : (afte_addr) );
>    afte = s390_fetch_fullword_absolute (afte_addr, regs);
>
>
>    if (afte & 0x80000000)
>        goto asn_afx_tran_excp;
>
>
>
>    if (!((regs)->cr[(0)].F.L.F & 0x00010000)) {
>        if (afte & 0x0000000F)
>              goto asn_asn_tran_spec_excp;
>    } else {
>        if (afte & 0x0000003F)
>              goto asn_asn_tran_spec_excp;
>    }
>
>
>
>    if (!((regs)->cr[(0)].F.L.F & 0x00010000)) {
>        aste_addr = afte & 0x7FFFFFF0;
>        aste_addr += (asn & 0x003F) << 4;
>        numwords = 4;
>    } else {
>        aste_addr = afte & 0x7FFFFFC0;
>        aste_addr += (asn & 0x003F) << 6;
>        numwords = 16;
>    }
>
>
>    aste_addr &= 0x7FFFFFFF;
>
>
>    if (aste_addr > regs->mainlim)
>        goto asn_addr_excp;
>
>
>    *asteo = aste_addr;
>
>
>
>
>    aste_addr = ( ((U32)(aste_addr) & 0x7FFFF000) == 0 || ((U32)(aste_addr) & 0x7FFFF000) == (regs->px.F.L.F) ? (U32)(aste_addr) ^ (regs->px.F.L.F) : (aste_addr) );
>    aste_main = s390_fetch_main_absolute((aste_addr), (regs));
>    for (i = 0; i < numwords; i++)
>    {
>        aste[i] = __bswap_32 (fetch_fw_noswap((aste_main)));
>        aste_main += 4;
>    }
>
>    while (i < 16) aste[i++] = 0;
>
>
>
>    if (aste[0] & 0x80000000)
>        goto asn_asx_tran_excp;
>
>
>
>    if ((aste[0] & 0x00000002) || (aste[1] & 0x0000000F)
>        || ((aste[0] & 0x00000001)
>
>            && !((regs)->cr[(0)].F.L.F & 0x00010000)
>
>            ))
>        goto asn_asn_tran_spec_excp;
>
>
>    return 0;
>
>
>asn_addr_excp:
>    code = 0x0005;
>    goto asn_prog_check;
>
>
>asn_asn_tran_spec_excp:
>    code = 0x0017;
>    goto asn_prog_check;
>
>
>asn_prog_check:
>    regs->program_interrupt (regs, code);
>
>
>asn_afx_tran_excp:
>    regs->ea.F.L.F = asn;
>    code = 0x0020;
>    return code;
>
>asn_asx_tran_excp:
>    regs->ea.F.L.F = asn;
>    code = 0x0021;
>    return code;
>
>}
># 203 "dat.h"
>static inline int s390_authorize_asn (U16 ax, U32 aste[],
>                                               int atemask, REGS *regs)
>{
>U32 ato;
>int atl;
>BYTE ate;
>
>
>
>
>    ato = aste[0] & 0x7FFFFFFC;
>    atl = aste[1] & 0x0000FFF0;
>
>
>    if ((ax & 0xFFF0) > atl)
>        return 1;
>
>
>
>    ato += (ax >> 2);
>
>
>    ato &= 0x7FFFFFFF;
>
>
>    if (ato > regs->mainlim)
>        goto auth_addr_excp;
>
>
>
>    ato = ( ((U32)(ato) & 0x7FFFF000) == 0 || ((U32)(ato) & 0x7FFFF000) == (regs->px.F.L.F) ? (U32)(ato) ^ (regs->px.F.L.F) : (ato) );
>
>    do { if(__builtin_expect((((regs))->sie_mode),0) && !(regs)->sie_pref) *(&ato) = ( ((((regs)->hostregs)->arch_mode == 1) ? s390_logical_to_main(((regs)->sie_mso + *(&ato)), (18), ((regs)->hostregs), ((0)), (0)) : z900_logical_to_main(((regs)->sie_mso + *(&ato)), (18), ((regs)->hostregs), ((0)), (0))), ((regs)->hostregs)->dat.aaddr ); } while(0);
>
>    ate = regs->mainstor[ato];
>    ate <<= ((ax & 0x03)*2);
>
>
>    (regs)->storkeys[(ato)>>11] |= 0x04;
>
>
>
>    if ((ate & atemask) == 0)
>        return 1;
>
>
>    return 0;
>
>
>auth_addr_excp:
>    regs->program_interrupt (regs, 0x0005);
>    return 1;
>
>}
># 299 "dat.h"
>static inline U16 s390_translate_alet (U32 alet, U16 eax,
>            int acctype, REGS *regs, U32 *asteo, U32 aste[])
>{
>U32 cb;
>U32 ald;
>U32 alo;
>U32 all;
>U32 ale[4];
>U32 aste_addr;
>U32 abs;
>BYTE *mn;
>int i;
>
>    regs->dat.protect = 0;
>
>
>    if ( alet & 0xFE000000 )
>        goto alet_spec_excp;
>
>
>
>
>
>
>    cb = (alet & 0x01000000) ?
>            regs->cr[(5)].F.L.F & 0x7FFFFFC0 :
>            regs->cr[(2)].F.L.F & 0x7FFFFFC0;
>
>
>    if (cb > regs->mainlim)
>        goto alet_addr_excp;
>
>
>
>
>
>    cb = ( ((U32)(cb) & 0x7FFFF000) == 0 || ((U32)(cb) & 0x7FFFF000) == (regs->px.F.L.F) ? (U32)(cb) ^ (regs->px.F.L.F) : (cb) );
>    ald = s390_fetch_fullword_absolute (cb+16, regs);
>
>
>
>
>    alo = ald & 0x7FFFFF80;
>    all = ald & 0x0000007F;
>
>
>    if (((alet & 0x0000FFFF) >> 3) > all)
>        goto alen_tran_excp;
>
>
>    alo += (alet & 0x0000FFFF) << 4;
>
>
>    if (alo > regs->mainlim)
>        goto alet_addr_excp;
>
>
>
>
>    alo = ( ((U32)(alo) & 0x7FFFF000) == 0 || ((U32)(alo) & 0x7FFFF000) == (regs->px.F.L.F) ? (U32)(alo) ^ (regs->px.F.L.F) : (alo) );
>    mn = s390_fetch_main_absolute((alo), (regs));
>    for (i = 0; i < 4; i++)
>    {
>        ale[i] = __bswap_32 (fetch_fw_noswap((mn)));
>        mn += 4;
>    }
>
>
>    if (ale[0] & 0x80000000)
>        goto alen_tran_excp;
>
>
>
>    if (!(acctype & 0x0800)
>        && (ale[0] & 0x00FF0000) != (alet & 0x00FF0000))
>        goto ale_seq_excp;
>
>
>    aste_addr = ale[2] & 0x7FFFFFC0;
>
>
>    abs = ( ((U32)(aste_addr) & 0x7FFFF000) == 0 || ((U32)(aste_addr) & 0x7FFFF000) == (regs->px.F.L.F) ? (U32)(aste_addr) ^ (regs->px.F.L.F) : (aste_addr) );
>    if (abs > regs->mainlim)
>        goto alet_addr_excp;
>    mn = s390_fetch_main_absolute((abs), (regs));
>
>
>
>
>    for (i = 0; i < 16; i++)
>    {
>        aste[i] = __bswap_32 (fetch_fw_noswap((mn)));
>        mn += 4;
>    }
>
>
>    if (aste[0] & 0x80000000)
>        goto aste_vald_excp;
>
>
>    if ((aste[5] & 0xFFFFFFFF) != (ale[3] & 0xFFFFFFFF))
>        goto aste_seq_excp;
>
>
>
>    if (!(acctype & 0x0800))
>    {
>
>
>
>        if ((ale[0] & 0x01000000)
>                && (ale[0] & 0x0000FFFF) != eax)
>        {
>
>
>            if ((aste[0] & 0x00000002) || (aste[1] & 0x0000000F)
>                || ((aste[0] & 0x00000001)
>
>                        && !((regs)->cr[(0)].F.L.F & 0x00010000)
>
>                   ))
>                goto alet_asn_tran_spec_excp;
>
>
>
>            if (s390_authorize_asn(eax, aste, 0x40, regs) != 0)
>                goto ext_auth_excp;
>        }
>
>    }
>
>
>    if (ale[0] & 0x02000000)
>        regs->dat.protect = 2;
>
>
>    *asteo = aste_addr;
>    return 0;
>
>
>
>alet_addr_excp:
>    regs->dat.xcode = 0x0005;
>    goto alet_prog_check;
>
>
>alet_asn_tran_spec_excp:
>    regs->dat.xcode = 0x0017;
>    goto alet_prog_check;
>
>
>alet_prog_check:
>    regs->program_interrupt (regs, regs->dat.xcode);
>
>
>alet_spec_excp:
>    regs->dat.xcode = 0x0028;
>    return regs->dat.xcode;
>
>alen_tran_excp:
>    regs->dat.xcode = 0x0029;
>    return regs->dat.xcode;
>
>ale_seq_excp:
>    regs->dat.xcode = 0x002A;
>    return regs->dat.xcode;
>
>aste_vald_excp:
>    regs->dat.xcode = 0x002B;
>    return regs->dat.xcode;
>
>aste_seq_excp:
>    regs->dat.xcode = 0x002C;
>    return regs->dat.xcode;
>
>ext_auth_excp:
>    regs->dat.xcode = 0x002D;
>    return regs->dat.xcode;
>
>}
>
>
>
>
>
>
>
>static inline void s390_purge_alb (REGS *regs)
>{
>int i;
>
>    for(i = 1; i < 16; i++)
>        if(regs->aea_ar[i] >= 16 && regs->aea_ar[i] != 32)
>            regs->aea_ar[i] = 0;
>
>    if(regs->host && regs->guestregs)
>        for(i = 1; i < 16; i++)
>            if(regs->guestregs->aea_ar[i] >= 16 && regs->guestregs->aea_ar[i] != 32)
>                regs->guestregs->aea_ar[i] = 0;
>
>}
>
>
>
>
>static inline void s390_purge_alb_all ()
>{
>int i;
>
>    for (i = 0; i < sysblk.maxcpu; i++)
>        if ((sysblk.regs[(i)] != ((void *)0))
>         && (sysblk.regs[i]->cpubit & sysblk.started_mask))
>            s390_purge_alb (sysblk.regs[i]);
>
>}
># 561 "dat.h"
>static inline U16 s390_load_address_space_designator (int arn,
>           REGS *regs, int acctype)
>{
>
>U32 alet;
>U32 asteo;
>U32 aste[16];
>U16 eax;
>
>
>
>
>    switch(arn) {
>
>    case 18:
>        regs->dat.stid = 0x000;
>        regs->dat.asd = regs->cr[(1)].F.L.F;
>        break;
>
>    case 17:
>        regs->dat.stid = 0x002;
>        regs->dat.asd = regs->cr[(7)].F.L.F;
>        break;
>
>    case 16:
>        regs->dat.stid = 0x003;
>        regs->dat.asd = regs->cr[(13)].F.L.F;
>        break;
>
>    case 19:
>        regs->dat.stid = 0;
>        regs->dat.asd = 0xFFFFFFFF;
>        break;
>
>    case 20:
>        switch(regs->aea_ar[20]) {
>
>        case 1:
>            regs->dat.stid = 0x000;
>            break;
>
>        case 13:
>            regs->dat.stid = 0x003;
>            break;
>
>        default:
>            regs->dat.stid = 0;
>        }
>
>        regs->dat.asd = regs->cr[(regs->aea_ar[20])].F.L.F;
>        break;
>
>    default:
>
>
>        if (((&regs->psw)->asc == 0x40)
>         || (((regs)->sie_active) && ( ((((regs->guestregs))->siebk->mx) & (0x01)) && (((&(regs->guestregs)->psw)->asc & ( 1 << (6) )) != 0) ))
>         || (arn & 16)
>           )
>        {
>
>            arn &= 0xF;
>
>
>            alet = (arn == 0) ? 0 :
>
>                   (((regs)->sie_active) && ( ((((regs->guestregs))->siebk->mx) & (0x01)) && (((&(regs->guestregs)->psw)->asc & ( 1 << (6) )) != 0) ))
>                   ? regs->guestregs->ar[(arn)] :
>
>                   ((regs)->sie_active) ? 0 :
>
>                   regs->ar[(arn)];
>
>
>            switch (alet) {
>
>            case 0:
>
>                regs->dat.stid = 0x000;
>                regs->dat.asd = regs->cr[(1)].F.L.F;
>                break;
>
>            case 1:
>
>                regs->dat.stid = 0x002;
>                regs->dat.asd = regs->cr[(7)].F.L.F;
>                break;
>
>            default:
>
>                if(regs->aea_ar[arn] >= 16 && regs->aea_ar[arn] != 32)
>                {
>                    regs->dat.asd = regs->cr[(regs->aea_ar[arn])].F.L.F;
>                    regs->dat.protect = regs->aea_aleprot[arn];
>                    regs->dat.stid = 0x001;
>                }
>                else
>                {
>
>                    eax = regs->cr[(8)].F.L.H.H.H;
>
>
>                    if (s390_translate_alet (alet, eax, acctype,
>                                                  regs, &asteo, aste))
>
>                        return regs->dat.xcode;
>
>
>                    regs->dat.asd = ((aste)[2]);
>                    regs->dat.stid = 0x001;
>                    if(regs->dat.protect & 2)
>                    {
>
>
>
>
>                       regs->dat.asd ^= 0x00000C00;
>                       regs->dat.asd |= 0x00000100;
>
>                    }
>
>
>                    regs->cr[(16 + arn)].F.L.F = regs->dat.asd;
>                    regs->aea_ar[arn] = 16 + arn;
>                    regs->aea_common[16 + arn] = (regs->dat.asd & 0x00000100) == 0;
>                    regs->aea_aleprot[arn] = regs->dat.protect & 2;
>
>                }
>
>            }
>
>            break;
>
>        }
>
>
>
>        if (((&regs->psw)->asc == 0x80))
>        {
>            regs->dat.stid = 0x002;
>            regs->dat.asd = regs->cr[(7)].F.L.F;
>            break;
>        }
>
>
>
>        if (((&regs->psw)->asc == 0xC0))
>        {
>            regs->dat.stid = 0x003;
>            regs->dat.asd = regs->cr[(13)].F.L.F;
>            break;
>        }
>
>
>
>        regs->dat.stid = 0x000;
>        regs->dat.asd = regs->cr[(1)].F.L.F;
>        break;
>
>    }
>
>    return 0;
>
>}
># 816 "dat.h"
>static inline int s390_translate_addr (U32 vaddr, int arn,
>                                            REGS *regs, int acctype)
>{
>U64 sto = 0;
>U64 pto = 0;
>int cc;
>int tlbix = (((U32)(vaddr) >> 12) & 0x3FF);
># 983 "dat.h"
>U32 stl;
>U64 ste;
>U64 pte;
>U32 ptl;
>
>    regs->dat.private = regs->dat.protect = 0;
>
>
>    if (s390_load_address_space_designator (arn, regs, acctype))
>        goto tran_alet_excp;
>
>
>    if ((regs->cr[(0)].F.L.F & 0x00F80000) != 0x00B00000)
>        goto tran_spec_excp;
>
>
>    regs->dat.private = ((regs->dat.asd & 0x00000100) != 0);
>
>
>    if ( ((vaddr & 0x7FC00000) | regs->tlbID) == regs->tlb.vaddr[(tlbix)].F.L.F
>        && (regs->tlb.common[tlbix] || regs->dat.asd == regs->tlb.asd[(tlbix)].F.L.F)
>        && !(regs->tlb.common[tlbix] && regs->dat.private)
>        && !(acctype & 0x0100) )
>    {
>        pte = regs->tlb.pte[(tlbix)].F.L.F;
>        if (regs->tlb.protect[tlbix])
>            regs->dat.protect = regs->tlb.protect[tlbix];
>    }
>    else
>    {
>
>
>
>        sto = regs->dat.asd & 0x7FFFF000;
>        stl = regs->dat.asd & 0x0000007F;
>        sto += (vaddr & 0x7FF00000) >> 18;
>
>
>        if ((vaddr >> 24) > stl)
>            goto seg_tran_length;
>
>
>        if (sto > regs->mainlim)
>            goto address_excp;
>
>
>
>        sto = ( ((U32)(sto) & 0x7FFFF000) == 0 || ((U32)(sto) & 0x7FFFF000) == (regs->px.F.L.F) ? (U32)(sto) ^ (regs->px.F.L.F) : (sto) );
>        ste = s390_fetch_fullword_absolute (sto, regs);
>
>
>        if (ste & 0x00000020)
>            goto seg_tran_invalid;
>
>
>        if (ste & 0x80000000)
>            goto tran_spec_excp;
>
>
>
>        if (regs->dat.private && (ste & (0x00000010)))
>            goto tran_spec_excp;
>
>
>        pto = ste & 0x7FFFFFC0;
>        ptl = ste & 0x0000000F;
>
>
>
>
>        pto += (vaddr & 0x000FF000) >> 10;
>
>
>        if (((vaddr & 0x000FF000) >> 16) > ptl)
>            goto page_tran_length;
>
>
>        if (pto > regs->mainlim)
>            goto address_excp;
>
>
>
>        pto = ( ((U32)(pto) & 0x7FFFF000) == 0 || ((U32)(pto) & 0x7FFFF000) == (regs->px.F.L.F) ? (U32)(pto) ^ (regs->px.F.L.F) : (pto) );
>        pte = s390_fetch_fullword_absolute (pto, regs);
>
>
>        if (pte & 0x00000400)
>            goto page_tran_invalid;
>
>
>        if (pte & 0x80000900)
>            goto tran_spec_excp;
>
>
>        if (pte & 0x00000200)
>            regs->dat.protect |= 1;
>
>
>        if (!(acctype & 0x0100))
>        {
>            regs->tlb.asd[(tlbix)].F.L.F = regs->dat.asd;
>            regs->tlb.vaddr[(tlbix)].F.L.F = (vaddr & 0x7FC00000) | regs->tlbID;
>            regs->tlb.pte[(tlbix)].F.L.F = pte;
>            regs->tlb.common[tlbix] = (ste & 0x00000010) ? 1 : 0;
>            regs->tlb.acc[tlbix] = 0;
>            regs->tlb.protect[tlbix] = regs->dat.protect;
>            regs->tlb.main[tlbix] = ((void *)0);
>        }
>    }
>
>    if(!(acctype & 0x0200))
>    {
>
>
>        regs->dat.raddr = (pte & 0x7FFFF000) | (vaddr & 0xFFF);
>        regs->dat.rpfra = (pte & 0x7FFFF000);
>    }
>    else
>
>
>        regs->dat.raddr = pto;
># 1568 "dat.h"
>    regs->dat.xcode = 0;
>    return 0;
>
>
>
>address_excp:
>
>
>    regs->dat.xcode = 0x0005;
>    goto tran_prog_check;
>
>tran_spec_excp:
># 1589 "dat.h"
>    regs->dat.xcode = 0x0012;
>    goto tran_prog_check;
>
>
>
>
>
>
>
>tran_prog_check:
># 1607 "dat.h"
>    regs->program_interrupt (regs, regs->dat.xcode);
>
>
>seg_tran_invalid:
>
>    if (acctype & 0x0400)
>    {
>        regs->dat.raddr = sto;
>        cc = 2;
>        return cc;
>    }
>
>
>    regs->dat.xcode = 0x0010;
>    regs->dat.raddr = sto;
>    cc = 1;
>    goto tran_excp_addr;
>
>page_tran_invalid:
>    regs->dat.xcode = 0x0011;
>    regs->dat.raddr = pto;
>    if(acctype & 0x0200) return 0;
>    cc = 2;
>    goto tran_excp_addr;
>
>
>page_tran_length:
>    regs->dat.xcode = 0x0011;
>    regs->dat.raddr = pto;
>    cc = 3;
>    goto tran_excp_addr;
>
>
>seg_tran_length:
>
>
>    regs->dat.xcode = 0x0010;
>    regs->dat.raddr = sto;
>    cc = 3;
>    goto tran_excp_addr;
>
>tran_alet_excp:
>    regs->excarid = arn;
>    cc = (acctype & 0x0400) ? 3 : 4;
>    return cc;
># 1713 "dat.h"
>tran_excp_addr:
>
>    if (acctype & 0x0400)
>        return 3;
>
>
>    regs->ea.F.L.F = vaddr & 0x7FFFF000;
># 1737 "dat.h"
>    if(regs->dat.stid == 0x001)
>    {
>        if ((regs->dat.asd & 0x7FFFF000) == (regs->cr[(1)].F.L.F & 0x7FFFF000))
>            regs->ea.F.L.F |= 0x000;
>        else if ((regs->dat.asd & 0x7FFFF000) == (regs->cr[(7)].F.L.F & 0x7FFFF000))
>            regs->ea.F.L.F |= 0x002;
>        else if ((regs->dat.asd & 0x7FFFF000) == (regs->cr[(13)].F.L.F & 0x7FFFF000))
>            regs->ea.F.L.F |= 0x003;
>        else
>            regs->ea.F.L.F |= 0x001;
>    }
>    else
>        if((regs->dat.stid == 0x002)
>          && (((&regs->psw)->asc == 0x00)
>            || ((&regs->psw)->asc == 0x80)))
>            regs->ea.F.L.F |= 0x002 | 0x80000000;
>        else
>            regs->ea.F.L.F |= regs->dat.stid;
># 1767 "dat.h"
>    if (((&regs->psw)->asc == 0x40)
>     || (((regs)->sie_active) && ( ((((regs->guestregs))->siebk->mx) & (0x01)) && (((&(regs->guestregs)->psw)->asc & ( 1 << (6) )) != 0) ))
>       )
>       regs->excarid = arn > 15 ? 0 : arn;
>
>
>    return cc;
>
>}
>
>
>
>
>
>static inline void s390_purge_tlb (REGS *regs)
>{
>    do { if ((regs)->aie) { (regs)->psw.ia.F.L.F = ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((0))) & ((((regs)))->psw.amask.F.L.F)); (regs)->aie = ((void *)0); } } while (0);
>    if (((++regs->tlbID) & 0x003FFFFF) == 0)
>    {
>        memset (&regs->tlb.vaddr, 0, 1024 * sizeof(DW));
>        regs->tlbID = 1;
>    }
>
>
>    if(regs->host && regs->guestregs)
>    {
>        do { if ((regs->guestregs)->aie) { (regs->guestregs)->psw.ia.F.L.F = ((U32)((((regs->guestregs)))->aiv.F.L.F + ((intptr_t)(((regs->guestregs)))->ip - (intptr_t)(((regs->guestregs)))->aip) + ((0))) & ((((regs->guestregs)))->psw.amask.F.L.F)); (regs->guestregs)->aie = ((void *)0); } } while (0);
>        if (((++regs->guestregs->tlbID) & 0x003FFFFF) == 0)
>        {
>            memset (&regs->guestregs->tlb.vaddr, 0, 1024 * sizeof(DW));
>            regs->guestregs->tlbID = 1;
>        }
>    }
>
>}
>
>
>
>
>
>static inline void s390_purge_tlb_all ()
>{
>int i;
>
>    for (i = 0; i < sysblk.maxcpu; i++)
>        if ((sysblk.regs[(i)] != ((void *)0))
>         && (sysblk.regs[i]->cpubit & sysblk.started_mask))
>            s390_purge_tlb (sysblk.regs[i]);
>
>}
>
>
>
>
>
>static inline void s390_purge_tlbe (REGS *regs, U64 pfra)
>{
>int i;
>U64 pte;
>U64 ptemask;
># 1835 "dat.h"
>    ptemask = 0x7FFFF000;
>    pte = pfra & ptemask;
>
>
>
>
>
>
>
>    do { if ((regs)->aie) { (regs)->psw.ia.F.L.F = ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((0))) & ((((regs)))->psw.amask.F.L.F)); (regs)->aie = ((void *)0); } } while (0);
>    for (i = 0; i < 1024; i++)
>        if ((regs->tlb.pte[(i)].F.L.F & ptemask) == pte)
>            regs->tlb.vaddr[(i)].F.L.F &= 0x7FC00000;
>
>
>
>    if (regs->host && regs->guestregs)
>    {
>        do { if ((regs->guestregs)->aie) { (regs->guestregs)->psw.ia.F.L.F = ((U32)((((regs->guestregs)))->aiv.F.L.F + ((intptr_t)(((regs->guestregs)))->ip - (intptr_t)(((regs->guestregs)))->aip) + ((0))) & ((((regs->guestregs)))->psw.amask.F.L.F)); (regs->guestregs)->aie = ((void *)0); } } while (0);
>        for (i = 0; i < 1024; i++)
>            if ((regs->guestregs->tlb.pte[(i)].F.L.F & ptemask) == pte)
>                regs->guestregs->tlb.vaddr[(i)].F.L.F &= 0x7FC00000;
>    }
>    else
>
>    if (regs->guest)
>    {
>        do { if ((regs->hostregs)->aie) { (regs->hostregs)->psw.ia.F.L.F = ((U32)((((regs->hostregs)))->aiv.F.L.F + ((intptr_t)(((regs->hostregs)))->ip - (intptr_t)(((regs->hostregs)))->aip) + ((0))) & ((((regs->hostregs)))->psw.amask.F.L.F)); (regs->hostregs)->aie = ((void *)0); } } while (0);
>        for (i = 0; i < 1024; i++)
>            if ((regs->hostregs->tlb.pte[(i)].F.L.F & ptemask) == pte)
>                regs->hostregs->tlb.vaddr[(i)].F.L.F &= 0x7FC00000;
>    }
>
>
>}
>
>
>
>
>
>static inline void s390_purge_tlbe_all (U64 pfra)
>{
>int i;
>
>    for (i = 0; i < sysblk.maxcpu; i++)
>        if ((sysblk.regs[(i)] != ((void *)0))
>         && (sysblk.regs[i]->cpubit & sysblk.started_mask))
>            s390_purge_tlbe (sysblk.regs[i], pfra);
>
>}
>
>
>
>
>
>static inline void s390_invalidate_tlb (REGS *regs, BYTE mask)
>{
>int i;
>
>    do { if ((regs)->aie) { (regs)->psw.ia.F.L.F = ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((0))) & ((((regs)))->psw.amask.F.L.F)); (regs)->aie = ((void *)0); } } while (0);
>    if (mask == 0)
>        memset(&regs->tlb.acc, 0, 1024);
>    else
>        for (i = 0; i < 1024; i++)
>            if ((regs->tlb.vaddr[(i)].F.L.F & 0x003FFFFF) == regs->tlbID)
>                regs->tlb.acc[i] &= mask;
>
>
>
>    if(regs->host && regs->guestregs)
>    {
>        do { if ((regs->guestregs)->aie) { (regs->guestregs)->psw.ia.F.L.F = ((U32)((((regs->guestregs)))->aiv.F.L.F + ((intptr_t)(((regs->guestregs)))->ip - (intptr_t)(((regs->guestregs)))->aip) + ((0))) & ((((regs->guestregs)))->psw.amask.F.L.F)); (regs->guestregs)->aie = ((void *)0); } } while (0);
>        if (mask == 0)
>            memset(&regs->guestregs->tlb.acc, 0, 1024);
>        else
>            for (i = 0; i < 1024; i++)
>                if ((regs->guestregs->tlb.vaddr[(i)].F.L.F & 0x003FFFFF) == regs->guestregs->tlbID)
>                    regs->guestregs->tlb.acc[i] &= mask;
>    }
>    else
>
>    if(regs->guest)
>    {
>        do { if ((regs->hostregs)->aie) { (regs->hostregs)->psw.ia.F.L.F = ((U32)((((regs->hostregs)))->aiv.F.L.F + ((intptr_t)(((regs->hostregs)))->ip - (intptr_t)(((regs->hostregs)))->aip) + ((0))) & ((((regs->hostregs)))->psw.amask.F.L.F)); (regs->hostregs)->aie = ((void *)0); } } while (0);
>        if (mask == 0)
>            memset(&regs->hostregs->tlb.acc, 0, 1024);
>        else
>            for (i = 0; i < 1024; i++)
>                if ((regs->hostregs->tlb.vaddr[(i)].F.L.F & 0x003FFFFF) == regs->hostregs->tlbID)
>                    regs->hostregs->tlb.acc[i] &= mask;
>    }
>
>
>}
># 1951 "dat.h"
>static inline void s390_invalidate_tlbe (REGS *regs, BYTE *main)
>{
>    int i;
>    int shift;
>    BYTE *mainwid;
>
>    if (main == ((void *)0))
>    {
>        s390_invalidate_tlb(regs, 0);
>        return;
>    }
>
>    mainwid = main + regs->tlbID;
>
>    do { if ((main) == (regs)->aip && (regs)->aie) { (regs)->psw.ia.F.L.F = ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((0))) & ((((regs)))->psw.amask.F.L.F)); (regs)->aie = ((void *)0); } } while (0);
>    shift = regs->arch_mode == 0 ? 11 : 12;
>    for (i = 0; i < 1024; i++)
>        if ((BYTE*)((uintptr_t)(regs->tlb.main[i]) ^ (uintptr_t)((regs->tlb.vaddr[(i)].F.L.F | (i << shift))))
>
>                     == mainwid)
>        {
>            regs->tlb.acc[i] = 0;
>
>
>
>
>        }
>
>
>
>    if (regs->host && regs->guestregs)
>    {
>        do { if ((main) == (regs->guestregs)->aip && (regs->guestregs)->aie) { (regs->guestregs)->psw.ia.F.L.F = ((U32)((((regs->guestregs)))->aiv.F.L.F + ((intptr_t)(((regs->guestregs)))->ip - (intptr_t)(((regs->guestregs)))->aip) + ((0))) & ((((regs->guestregs)))->psw.amask.F.L.F)); (regs->guestregs)->aie = ((void *)0); } } while (0);
>        shift = regs->guestregs->arch_mode == 0 ? 11 : 12;
>        for (i = 0; i < 1024; i++)
>            if ((BYTE*)((uintptr_t)(regs->guestregs->tlb.main[i]) ^ (uintptr_t)((regs->guestregs->tlb.vaddr[(i)].F.L.F | (i << shift))))
>
>                         == mainwid)
>            {
>                regs->guestregs->tlb.acc[i] = 0;
>
>
>
>
>            }
>    }
>
>
>    if (regs->guest)
>    {
>        do { if ((main) == (regs->hostregs)->aip && (regs->hostregs)->aie) { (regs->hostregs)->psw.ia.F.L.F = ((U32)((((regs->hostregs)))->aiv.F.L.F + ((intptr_t)(((regs->hostregs)))->ip - (intptr_t)(((regs->hostregs)))->aip) + ((0))) & ((((regs->hostregs)))->psw.amask.F.L.F)); (regs->hostregs)->aie = ((void *)0); } } while (0);
>        shift = regs->hostregs->arch_mode == 0 ? 11 : 12;
>        for (i = 0; i < 1024; i++)
>            if ((BYTE*)((uintptr_t)(regs->hostregs->tlb.main[i]) ^ (uintptr_t)((regs->hostregs->tlb.vaddr[(i)].F.L.F | (i << shift))))
>
>                         == mainwid)
>            {
>                regs->hostregs->tlb.acc[i] = 0;
>
>
>
>
>            }
>    }
>
>
>
>}
># 2041 "dat.h"
>static inline void s390_invalidate_pte (BYTE ibyte, U64 op1,
>                                                    U32 op2, REGS *regs)
>{
>U64 raddr;
>U64 pte;
>U64 pfra;
>
>    ((ibyte)=(ibyte));
># 2095 "dat.h"
>    {
>
>        if ((regs->cr[(0)].F.L.F & 0x00F80000) != 0x00B00000)
>            regs->program_interrupt (regs,
>                              0x0012);
>
>
>
>
>        raddr = (op1 & 0x7FFFFFC0)
>                    + ((op2 & 0x000FF000) >> 10);
>        raddr &= 0x7FFFFFFF;
>
>
>
>        pte = s390_vfetch4 ( raddr, 19, regs );
>
>
>
>
>        if(ibyte == 0x59)
>            pte &= ~0x00000100;
>        else
>
>            pte |= 0x00000400;
>        s390_vstore4 ( pte, raddr, 19, regs );
>        pfra = pte & 0x7FFFF000;
>    }
># 2153 "dat.h"
>    s390_purge_tlbe_all (pfra);
>
>}
># 2165 "dat.h"
>static inline int s390_check_sa_per2 (int arn, int acctype, REGS *regs)
>{
>    ((acctype)=(acctype));
>    if((regs->dat.asd & 0x00000080) || !(regs->cr[(9)].F.L.F & 0x00200000))
>    {
>        regs->peraid = arn > 0 && arn < 16 ? arn : 0;
>        regs->perc |= regs->dat.stid;
>        return 1;
>    }
>    return 0;
>}
># 2210 "dat.h"
>static inline BYTE *s390_logical_to_main_l (U32 addr, int arn,
>                                    REGS *regs, int acctype, BYTE akey,
>                                    size_t len)
>{
>U64 aaddr;
>U64 apfra;
>int ix = (((U32)(addr) >> 12) & 0x3FF);
>
>
>    if ( ((((&regs->psw)->sysmask & 0x04)==0) || arn == 19)
>
>
>
>      && !(regs->sie_active
>
>
>
>
>
>
>          )
>
>       )
>    {
>        regs->dat.private = regs->dat.protect = 0;
>        regs->dat.raddr = addr;
>        regs->dat.rpfra = addr & 0x7FFFF000;
>
>
>        regs->tlb.asd[(ix)].F.L.F = 0xFFFFFFFF;
>        regs->tlb.vaddr[(ix)].F.L.F = (addr & 0x7FC00000) | regs->tlbID;
>        regs->tlb.pte[(ix)].F.L.F = addr & 0x7FC00000;
>        regs->tlb.acc[ix] =
>        regs->tlb.common[ix] =
>        regs->tlb.protect[ix] = 0;
>    }
>    else {
>        if (s390_translate_addr (addr, arn, regs, acctype))
>            goto vabs_prog_check;
>    }
>
>    if (regs->dat.protect
>     && (acctype & (0x0002|0x0001)))
>        goto vabs_prot_excp;
>
>
>    regs->dat.aaddr = aaddr = ( ((U32)(regs->dat.raddr) & 0x7FFFF000) == 0 || ((U32)(regs->dat.raddr) & 0x7FFFF000) == (regs->px.F.L.F) ? (U32)(regs->dat.raddr) ^ (regs->px.F.L.F) : (regs->dat.raddr) );
>    apfra=( ((U32)(regs->dat.rpfra) & 0x7FFFF000) == 0 || ((U32)(regs->dat.rpfra) & 0x7FFFF000) == (regs->px.F.L.F) ? (U32)(regs->dat.rpfra) ^ (regs->px.F.L.F) : (regs->dat.rpfra) );
>
>
>    if (regs->dat.aaddr > regs->mainlim)
>        goto vabs_addr_excp;
>
>
>    if(__builtin_expect(((regs)->sie_mode),0)) regs->hostregs->dat.protect = 0;
>    if(__builtin_expect(((regs)->sie_mode),0) && !regs->sie_pref)
>    {
>
>        if (( ((regs->hostregs)->arch_mode == 1) ? s390_translate_addr((regs->sie_mso + regs->dat.aaddr), ((arn > 0 && arn < 16 && ( ((((regs))->siebk->mx) & (0x01)) && (((&(regs)->psw)->asc & ( 1 << (6) )) != 0) )) ? arn : 18), (regs->hostregs), (0)) : z900_translate_addr((regs->sie_mso + regs->dat.aaddr), ((arn > 0 && arn < 16 && ( ((((regs))->siebk->mx) & (0x01)) && (((&(regs)->psw)->asc & ( 1 << (6) )) != 0) )) ? arn : 18), (regs->hostregs), (0)) )
>
>                                                )
>            (regs->hostregs->program_interrupt) (regs->hostregs, regs->hostregs->dat.xcode);
>
>        regs->dat.protect |= regs->hostregs->dat.protect;
>        regs->tlb.protect[ix] |= regs->hostregs->dat.protect;
>
>        if ( (((&regs->psw)->sysmask & 0x04)==0) || (arn == 19) )
>            regs->tlb.pte[(ix)].F.L.F = addr & 0x7FC00000;
>
>
>        if (arn > 0 && arn < 16 && ( ((((regs))->siebk->mx) & (0x01)) && (((&(regs)->psw)->asc & ( 1 << (6) )) != 0) ))
>        {
>            regs->tlb.asd[(ix)].F.L.F = regs->dat.asd;
>
>            regs->dat.private = regs->hostregs->dat.private;
>
>
>            regs->dat.asd = regs->hostregs->dat.asd ^ 0x800;
>            regs->cr[(16 + arn)].F.L.F = regs->dat.asd;
>            regs->aea_ar[arn] = 16 + arn;
>            regs->aea_common[16 + arn] = (regs->dat.asd & 0x00000100) == 0;
>            regs->aea_aleprot[arn] = regs->hostregs->dat.protect & 2;
>        }
>
>
>        regs->hostregs->dat.aaddr = aaddr =
>              ( ((U32)(regs->hostregs->dat.raddr) & 0x7FFFF000) == 0 || ((U32)(regs->hostregs->dat.raddr) & 0x7FFFF000) == (regs->hostregs->px.F.L.F) ? (U32)(regs->hostregs->dat.raddr) ^ (regs->hostregs->px.F.L.F) : (regs->hostregs->dat.raddr) );
>        apfra = ( ((U32)(regs->hostregs->dat.rpfra) & 0x7FFFF000) == 0 || ((U32)(regs->hostregs->dat.rpfra) & 0x7FFFF000) == (regs->hostregs->px.F.L.F) ? (U32)(regs->hostregs->dat.rpfra) ^ (regs->hostregs->px.F.L.F) : (regs->hostregs->dat.rpfra) );
>
>        if(regs->hostregs->dat.aaddr > regs->hostregs->mainlim)
>            goto vabs_addr_excp;
># 2310 "dat.h"
>    }
>
>
>
>    regs->dat.storkey = &((regs)->storkeys[(aaddr)>>11]);
>
>
>
>    if (__builtin_expect((((regs)->sie_active)),0))
>        return regs->mainstor + aaddr;
>
>
>    if (__builtin_expect((acctype & 0x0004),1))
>    {
>
>        if (__builtin_expect((s390_is_fetch_protected (addr, *regs->dat.storkey, akey, regs)),0))
>        {
>            if (__builtin_expect(((regs)->sie_mode),0)) regs->hostregs->dat.protect = 0;
>            goto vabs_prot_excp;
>        }
>
>
>        *regs->dat.storkey |= 0x04;
>
>
>        regs->tlb.storkey[ix] = regs->dat.storkey;
>        regs->tlb.skey[ix] = *regs->dat.storkey & 0xF0;
>        regs->tlb.acc[ix] = 0x0004;
>        regs->tlb.main[ix] = (BYTE*)((uintptr_t)((regs)->mainstor + (uintptr_t)(apfra)) ^ (uintptr_t)((addr) & 0x7FFFF000));
>
>    }
>    else
>    {
>
>        if (__builtin_expect((s390_is_store_protected (addr, *regs->dat.storkey, akey, regs)),0))
>        {
>            if (__builtin_expect(((regs)->sie_mode),0)) regs->hostregs->dat.protect = 0;
>            goto vabs_prot_excp;
>        }
>        if (__builtin_expect(((regs)->sie_mode),0) && regs->hostregs->dat.protect)
>            goto vabs_prot_excp;
>
>
>        if (acctype & 0x0002)
>            *regs->dat.storkey |= (0x04 | 0x02);
>
>
>        regs->tlb.storkey[ix] = regs->dat.storkey;
>        regs->tlb.skey[ix] = *regs->dat.storkey & 0xF0;
>        regs->tlb.acc[ix] = (addr >= 4096 || regs->dat.private)
>                              ? (0x0004|0x0001|acctype)
>                              : 0x0004;
>        regs->tlb.main[ix] = (BYTE*)((uintptr_t)((regs)->mainstor + (uintptr_t)(apfra)) ^ (uintptr_t)((addr) & 0x7FFFF000));
>
>
>        if (( __builtin_expect(((regs)->permode),0) && ((regs)->ints_state & ( 1 << (21) )) ))
>        {
>            regs->tlb.acc[ix] = 0x0004;
>            if (arn != 19
>
>            && ( (((&regs->psw)->sysmask & 0x04)==0) ||
>               s390_check_sa_per2 (arn, acctype, regs)
>               )
>
>
>            && ( (((regs->cr[(11)].F.L.F) & 0x7FFFFFFF) >= ((regs->cr[(10)].F.L.F) & 0x7FFFFFFF)) ? (((addr) >= ((regs->cr[(10)].F.L.F) & 0x7FFFFFFF)) && (addr) <= ((regs->cr[(11)].F.L.F) & 0x7FFFFFFF)) || (((addr+(len-1)) >= ((regs->cr[(10)].F.L.F) & 0x7FFFFFFF)) && (addr+(len-1)) <= ((regs->cr[(11)].F.L.F) & 0x7FFFFFFF)) || (((addr) <= ((regs->cr[(10)].F.L.F) & 0x7FFFFFFF)) && (addr+(len-1)) >= ((regs->cr[(11)].F.L.F) & 0x7FFFFFFF)) : (((addr+(len-1)) >= ((regs->cr[(10)].F.L.F) & 0x7FFFFFFF)) || (addr) <= ((regs->cr[(11)].F.L.F) & 0x7FFFFFFF)) )
>            )
>                do { (regs)->ints_mask |= ( 1 << (21) ); } while (0);
>        }
>
>    }
>
>
>    return regs->mainstor + aaddr;
>
>vabs_addr_excp:
>    regs->program_interrupt (regs, 0x0005);
>
>vabs_prot_excp:
>
>    regs->ea.F.L.F = addr & 0x7FFFF000;
>    if (regs->dat.protect && (acctype & (0x0002|0x0001)) )
>    {
>        regs->ea.F.L.F |= 0x004;
>
>
>
>
>    }
>    regs->ea.F.L.F |= regs->dat.stid;
>    regs->excarid = (arn > 0 && arn < 16 ? arn : 0);
>
>
>
>    if(__builtin_expect(((regs)->sie_mode),0) && regs->hostregs->dat.protect)
>    {
>
>        regs->hostregs->ea.F.L.F = regs->ea.F.L.F;
>        regs->hostregs->excarid = regs->excarid;
>
>        (regs->hostregs->program_interrupt) (regs->hostregs, 0x0004);
>    }
>    else
>
>        regs->program_interrupt (regs, 0x0004);
>
>vabs_prog_check:
>    regs->program_interrupt (regs, regs->dat.xcode);
>
>    return ((void *)0);
>}
>
>
>static inline BYTE *s390_logical_to_main (U32 addr, int arn,
>                                    REGS *regs, int acctype, BYTE akey)
>{
>    return s390_logical_to_main_l(addr,arn,regs,acctype,akey,1);
>}
># 735 "inline.h" 2
>
># 1 "vstore.h" 1
># 153 "vstore.h"
>static inline void s390_vstorec (void *src, BYTE len,
>                                        U32 addr, int arn, REGS *regs)
>{
>BYTE *main1, *main2;
>BYTE *sk;
>int len2;
>
>    if ( __builtin_expect((( (int)((addr) & 0x7FF)) <= ( 0x7FF - (len) )),1) )
>    {
>        memcpy(( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].F.L.F == (regs)->tlb.asd[((((U32)(addr) >> 12) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 12) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 12) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0x7FC00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)(addr) >> 12) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( s390_logical_to_main_l ((addr), (arn), (regs), (0x0002), (regs->psw.pkey), (len+1)) ) ),
>               src, len + 1);
>        ;
>    }
>    else
>    {
>        len2 = 0x800 - (addr & 0x7FF);
>        main1 = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].F.L.F == (regs)->tlb.asd[((((U32)(addr) >> 12) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 12) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 12) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0x7FC00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0001) & (regs)->tlb.acc[(((U32)(addr) >> 12) & 0x3FF)]),1) ? ( ((0x0001) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( s390_logical_to_main_l ((addr), (arn), (regs), (0x0001), (regs->psw.pkey), (len2)) ) )
>                                     ;
>        sk = regs->dat.storkey;
>        main2 = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].F.L.F == (regs)->tlb.asd[((((U32)((addr + len2) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)((addr + len2) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)((addr + len2) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr + len2) & ((regs)->psw.amask.F.L.F)) & 0x7FC00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)((addr + len2) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)((addr + len2) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)((addr + len2) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)((addr + len2) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr + len2) & ((regs)->psw.amask.F.L.F)))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)((addr + len2) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr + len2) & ((regs)->psw.amask.F.L.F)))) ) : ( s390_logical_to_main_l (((addr + len2) & ((regs)->psw.amask.F.L.F)), (arn), (regs), (0x0002), (regs->psw.pkey), (len+1-len2)) ) )
>
>                                                          ;
>        *sk |= (0x04 | 0x02);
>        memcpy (main1, src, len2);
>        memcpy (main2, (BYTE*)src + len2, len + 1 - len2);
>    }
>
>}
># 195 "vstore.h"
>static inline void s390_vstoreb (BYTE value, U32 addr,
>                                         int arn, REGS *regs)
>{
>BYTE *main1;
>
>    main1 = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0002)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0002)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s390_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0002)), ((regs->psw.pkey)), (1)) ) );
>    *main1 = value;
>    ;
>
>}
># 219 "vstore.h"
>static void s390_vstore2_full(U16 value, U32 addr,
>                                              int arn, REGS *regs)
>{
>BYTE *main1, *main2;
>BYTE *sk;
>
>    main1 = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0001)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0001)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s390_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0001)), ((regs->psw.pkey)), (1)) ) );
>    sk = regs->dat.storkey;
>    main2 = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)(((addr + 1) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)(((addr + 1) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)(((addr + 1) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]),1) && __builtin_expect(((((((addr + 1) & ((regs)->psw.amask.F.L.F))) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr + 1) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0002)) & ((regs))->tlb.acc[(((U32)(((addr + 1) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]),1) ? ( (((0x0002)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr + 1) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + 1) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + 1) & ((regs)->psw.amask.F.L.F))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + 1) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + 1) & ((regs)->psw.amask.F.L.F))))) ) : ( s390_logical_to_main_l ((((addr + 1) & ((regs)->psw.amask.F.L.F))), ((arn)), ((regs)), ((0x0002)), ((regs->psw.pkey)), (1)) ) )
>                                                ;
>    *sk |= (0x04 | 0x02);
>    *main1 = value >> 8;
>    *main2 = value & 0xFF;
>
>}
>
>
>static inline void s390_vstore2 (U16 value, U32 addr, int arn,
>                                                            REGS *regs)
>{
>
>    if (__builtin_expect((!((U32)addr & 1) || ((U32)addr & 0x7FF) != 0x7FF),1))
>    {
>        BYTE *mn;
>        mn = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].F.L.F == (regs)->tlb.asd[((((U32)(addr) >> 12) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 12) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 12) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0x7FC00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)(addr) >> 12) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( s390_logical_to_main_l ((addr), (arn), (regs), (0x0002), (regs->psw.pkey), (2)) ) );
>        store_hw_noswap((mn), (__extension__ ({ unsigned short int __v, __x = (unsigned short int) ((value)); if (__builtin_constant_p (__x)) __v = ((unsigned short int) ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8))); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })));
>        ;
>    }
>    else
>        s390_vstore2_full(value, addr, arn, regs);
>}
># 264 "vstore.h"
>static void s390_vstore4_full(U32 value, U32 addr,
>                                              int arn, REGS *regs)
>{
>BYTE *main1, *main2;
>BYTE *sk;
>int len;
>BYTE temp[4];
>
>    len = 0x800 - (addr & 0x7FF);
>    main1 = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].F.L.F == (regs)->tlb.asd[((((U32)(addr) >> 12) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 12) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 12) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0x7FC00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0001) & (regs)->tlb.acc[(((U32)(addr) >> 12) & 0x3FF)]),1) ? ( ((0x0001) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( s390_logical_to_main_l ((addr), (arn), (regs), (0x0001), (regs->psw.pkey), (len)) ) );
>    sk = regs->dat.storkey;
>    main2 = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].F.L.F == (regs)->tlb.asd[((((U32)((addr + len) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)((addr + len) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)((addr + len) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr + len) & ((regs)->psw.amask.F.L.F)) & 0x7FC00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)((addr + len) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)((addr + len) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)((addr + len) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)((addr + len) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr + len) & ((regs)->psw.amask.F.L.F)))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)((addr + len) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr + len) & ((regs)->psw.amask.F.L.F)))) ) : ( s390_logical_to_main_l (((addr + len) & ((regs)->psw.amask.F.L.F)), (arn), (regs), (0x0002), (regs->psw.pkey), (4-len)) ) )
>                                                ;
>    *sk |= (0x04 | 0x02);
>    store_fw_noswap((temp), __bswap_32 ((value)));
>    memcpy(main1, temp, len);
>    memcpy(main2, temp+len, 4-len);
>
>}
>
>
>static inline void s390_vstore4 (U32 value, U32 addr, int arn,
>                                                            REGS *regs)
>{
>
>    if(__builtin_expect((!((U32)addr & 0x03)),1) || (((U32)addr & 0x7ff) <= 0x7fc))
>    {
>        BYTE *mn;
>        mn = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].F.L.F == (regs)->tlb.asd[((((U32)(addr) >> 12) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 12) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 12) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0x7FC00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)(addr) >> 12) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( s390_logical_to_main_l ((addr), (arn), (regs), (0x0002), (regs->psw.pkey), (4)) ) );
>        store_fw_noswap((mn), __bswap_32 ((value)));
>        ;
>    }
>    else
>        s390_vstore4_full(value,addr,arn,regs);
>}
># 316 "vstore.h"
>static void s390_vstore8_full(U64 value, U32 addr,
>                                              int arn, REGS *regs)
>{
>BYTE *main1, *main2;
>BYTE *sk;
>int len;
>BYTE temp[8];
>
>    len = 0x800 - (addr & 0x7FF);
>    main1 = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].F.L.F == (regs)->tlb.asd[((((U32)(addr) >> 12) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 12) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 12) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0x7FC00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0001) & (regs)->tlb.acc[(((U32)(addr) >> 12) & 0x3FF)]),1) ? ( ((0x0001) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( s390_logical_to_main_l ((addr), (arn), (regs), (0x0001), (regs->psw.pkey), (len)) ) );
>    sk = regs->dat.storkey;
>    main2 = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].F.L.F == (regs)->tlb.asd[((((U32)((addr + len) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)((addr + len) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)((addr + len) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr + len) & ((regs)->psw.amask.F.L.F)) & 0x7FC00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)((addr + len) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)((addr + len) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)((addr + len) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)((addr + len) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr + len) & ((regs)->psw.amask.F.L.F)))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)((addr + len) & ((regs)->psw.amask.F.L.F)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr + len) & ((regs)->psw.amask.F.L.F)))) ) : ( s390_logical_to_main_l (((addr + len) & ((regs)->psw.amask.F.L.F)), (arn), (regs), (0x0002), (regs->psw.pkey), (8-len)) ) )
>                                                ;
>    *sk |= (0x04 | 0x02);
>    store_dw_i686_noswap((temp),__bswap_64 ((value)));
>    memcpy(main1, temp, len);
>    memcpy(main2, temp+len, 8-len);
>
>}
>static inline void s390_vstore8 (U64 value, U32 addr, int arn,
>                                                            REGS *regs)
>{
>
>
>
>    if(__builtin_expect((!((U32)addr & 0x07)),1))
>    {
>
>        U64 *mn;
>        mn = (U64*)( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].F.L.F == (regs)->tlb.asd[((((U32)(addr) >> 12) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 12) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 12) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0x7FC00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)(addr) >> 12) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( s390_logical_to_main_l ((addr), (arn), (regs), (0x0002), (regs->psw.pkey), (8)) ) );
>        if (regs->cpubit == regs->sysblk->started_mask)
>            *mn = __bswap_64 (value);
>        else
>        store_dw_i686_noswap((mn),__bswap_64 ((value)));
>    }
>    else
>
>    {
>
>
>
>
>
>        if(__builtin_expect((((U32)addr & 0x7ff) <= 0x7f8),1))
>        {
>
>            BYTE *mn;
>            mn = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].F.L.F == (regs)->tlb.asd[((((U32)(addr) >> 12) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 12) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 12) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0x7FC00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)(addr) >> 12) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( s390_logical_to_main_l ((addr), (arn), (regs), (0x0002), (regs->psw.pkey), (8)) ) );
>
>            store_dw_i686_noswap((mn),__bswap_64 ((value)));
>        }
>        else
>
>            s390_vstore8_full(value,addr,arn,regs);
>    }
>    ;
>}
># 389 "vstore.h"
>static inline void s390_vfetchc (void *dest, BYTE len,
>                                        U32 addr, int arn, REGS *regs)
>{
>BYTE *main1, *main2;
>int len2;
>
>    main1 = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s390_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>
>    if ( __builtin_expect((( (int)((addr) & 0x7FF)) <= ( 0x7FF - (len) )),1) )
>    {
>        ;
>        memcpy (dest, main1, len + 1);
>    }
>    else
>    {
>        len2 = 0x800 - (addr & 0x7FF);
>        main2 = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)(((addr + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)(((addr + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)(((addr + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]),1) && __builtin_expect(((((((addr + len2) & ((regs)->psw.amask.F.L.F))) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)(((addr + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + len2) & ((regs)->psw.amask.F.L.F))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + len2) & ((regs)->psw.amask.F.L.F))))) ) : ( s390_logical_to_main_l ((((addr + len2) & ((regs)->psw.amask.F.L.F))), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) )
>                                                               ;
>        memcpy (dest, main1, len2);
>        memcpy ((BYTE*)dest + len2, main2, len + 1 - len2);
>    }
>
>}
># 427 "vstore.h"
>static inline BYTE s390_vfetchb (U32 addr, int arn,
>                                         REGS *regs)
>{
>BYTE *mn;
>
>    ;
>    mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s390_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>    return *mn;
>}
># 451 "vstore.h"
>static U16 s390_vfetch2_full (U32 addr, int arn,
>                                             REGS *regs)
>{
>BYTE *mn;
>U16 value;
>
>    mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s390_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>    value = *mn << 8;
>    mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)(((addr + 1) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)(((addr + 1) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)(((addr + 1) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]),1) && __builtin_expect(((((((addr + 1) & ((regs)->psw.amask.F.L.F))) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr + 1) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)(((addr + 1) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr + 1) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + 1) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + 1) & ((regs)->psw.amask.F.L.F))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + 1) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + 1) & ((regs)->psw.amask.F.L.F))))) ) : ( s390_logical_to_main_l ((((addr + 1) & ((regs)->psw.amask.F.L.F))), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) )
>                                              ;
>    value |= *mn;
>    return value;
>
>}
>
>static inline U16 s390_vfetch2 (U32 addr, int arn, REGS *regs)
>{
>    if(__builtin_expect((!((U32)addr & 0x01)),1) || (((U32)addr & 0x7ff) !=0x7ff ))
>    {
>    BYTE *mn;
>        ;
>        mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s390_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>        return (__extension__ ({ unsigned short int __v, __x = (unsigned short int) (fetch_hw_noswap((mn))); if (__builtin_constant_p (__x)) __v = ((unsigned short int) ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8))); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; }));
>    }
>    return(s390_vfetch2_full(addr,arn,regs));
>}
># 492 "vstore.h"
>static U32 s390_vfetch4_full (U32 addr, int arn,
>                                             REGS *regs)
>{
>BYTE *mn;
>int len;
>BYTE temp[8];
>
>    mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s390_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>    memcpy(temp, mn, 4);
>    len = 0x800 - (addr & 0x7FF);
>    mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]),1) && __builtin_expect(((((((addr + len) & ((regs)->psw.amask.F.L.F))) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + len) & ((regs)->psw.amask.F.L.F))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + len) & ((regs)->psw.amask.F.L.F))))) ) : ( s390_logical_to_main_l ((((addr + len) & ((regs)->psw.amask.F.L.F))), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) )
>                                              ;
>    memcpy(temp+len, mn, 4);
>    return __bswap_32 (fetch_fw_noswap((temp)));
>
>}
>
>static inline U32 s390_vfetch4 (U32 addr, int arn, REGS *regs)
>{
>    if ( (__builtin_expect((!((U32)addr & 0x03)),1) || (((U32)addr & 0x7ff) <= 0x7fc )))
>    {
>    BYTE *mn;
>        ;
>        mn=( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s390_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>        return __bswap_32 (fetch_fw_noswap((mn)));
>    }
>    return(s390_vfetch4_full(addr,arn,regs));
>}
># 535 "vstore.h"
>static U64 s390_vfetch8_full (U32 addr, int arn,
>                                             REGS *regs)
>{
>BYTE *mn;
>int len;
>BYTE temp[16];
>
>
>    mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s390_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>    memcpy(temp, mn, 8);
>    len = 0x800 - (addr & 0x7FF);
>    mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]),1) && __builtin_expect(((((((addr + len) & ((regs)->psw.amask.F.L.F))) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + len) & ((regs)->psw.amask.F.L.F))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + len) & ((regs)->psw.amask.F.L.F))))) ) : ( s390_logical_to_main_l ((((addr + len) & ((regs)->psw.amask.F.L.F))), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) )
>                                             ;
>    memcpy(temp+len, mn, 8);
>    return __bswap_64 (fetch_dw_i686_noswap((temp)));
>
>}
>
>static inline U64 s390_vfetch8 (U32 addr, int arn, REGS *regs)
>{
>
>    if(__builtin_expect((!((U32)addr & 0x07)),1))
>    {
>
>        U64 *mn;
>        ;
>        mn=(U64*)( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s390_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>        if (regs->cpubit == regs->sysblk->started_mask)
>            return __bswap_64 (*mn);
>        return __bswap_64 (fetch_dw_i686_noswap((mn)));
>    }
>    else
>
>    {
>
>        if(__builtin_expect((((U32)addr & 0x7ff) <= 0x7f8),1))
>        {
>
>            BYTE *mn;
>            ;
>            mn=( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s390_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>            return __bswap_64 (fetch_dw_i686_noswap((mn)));
>        }
>    }
>
>    return s390_vfetch8_full(addr,arn,regs);
>}
># 623 "vstore.h"
>static inline BYTE * s390_instfetch (REGS *regs, int exec)
>{
>U32 addr;
>BYTE *ia;
>BYTE *dest;
>int pagesz;
>int offset;
>int len;
>
>    while (0);
>
>    addr = exec ? regs->et.F.L.F
>         : __builtin_expect((regs->aie == ((void *)0)),1) ? regs->psw.ia.F.L.F : ((U32)(((regs))->aiv.F.L.F + ((intptr_t)((regs))->ip - (intptr_t)((regs))->aip) + ((0))) & (((regs))->psw.amask.F.L.F));
>
>    offset = (int)(addr & 0x00000FFF);
>
>
>    if ( __builtin_expect((offset & 0x01),0) )
>    {
>        if (!exec) regs->instinvalid = 1;
>        regs->program_interrupt(regs, 0x0006);
>    }
>    pagesz = __builtin_expect((addr < 0x800),0) ? 0x800 : 4096;
>
>
>
>    if( __builtin_expect(((regs)->permode),0) )
>    {
>
>        regs->perc = 0x40
>                   | (regs->psw.amode64 << 7)
>                   | (regs->psw.amode << 5)
>                   | (!(((&regs->psw)->sysmask & 0x04)==0) ? 0x10 : 0)
>                   | ((((&regs->psw)->asc & ( 1 << (7) )) != 0) << 3)
>                   | ((((&regs->psw)->asc & ( 1 << (6) )) != 0) << 2);
>
>
>
>
>        if(!exec)
>            regs->peradr = addr;
>
>
>        if( ( __builtin_expect(((regs)->permode),0) && ((regs)->ints_state & ( 1 << (22) )) )
>          && ( (((regs->cr[(11)].F.L.F) & 0x7FFFFFFF) >= ((regs->cr[(10)].F.L.F) & 0x7FFFFFFF)) ? (((addr) >= ((regs->cr[(10)].F.L.F) & 0x7FFFFFFF)) && (addr) <= ((regs->cr[(11)].F.L.F) & 0x7FFFFFFF)) : (((addr) >= ((regs->cr[(10)].F.L.F) & 0x7FFFFFFF)) || (addr) <= ((regs->cr[(11)].F.L.F) & 0x7FFFFFFF)) ) )
>        {
>            do { (regs)->ints_mask |= ( 1 << (22) ); } while (0);
># 682 "vstore.h"
>        }
>
>        if (!exec && !regs->tracing
>         && regs->aie && regs->ip < regs->aip + pagesz - 5)
>            return regs->ip;
>    }
>
>
>    if (!exec) regs->instinvalid = 1;
>
>
>    ia = ( __builtin_expect((((regs))->aea_ar[((20))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((20))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((20))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s390_logical_to_main_l (((addr)), ((20)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>
>
>    if ( offset + ((ia[0]) < 0x40 ? 2 : (ia[0]) < 0xc0 ? 4 : 6) > pagesz )
>    {
>
>        dest = exec ? regs->exinst : regs->inst;
>        memcpy (dest, ia, 4);
>        len = pagesz - offset;
>        offset = 0;
>        addr = (addr + len) & ((regs)->psw.amask.F.L.F);
>        ia = ( __builtin_expect((((regs))->aea_ar[((20))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((20))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((20))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s390_logical_to_main_l (((addr)), ((20)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>        if (!exec) regs->ip = ia - len;
>        memcpy(dest + len, ia, 4);
>    }
>    else
>    {
>        dest = ia;
>        if (!exec) regs->ip = ia;
>    }
>
>    if (!exec)
>    {
>        regs->instinvalid = 0;
>
>
>        regs->aiv.F.L.F = addr & 0x7FFFF000;
>        regs->aip = (BYTE *)((uintptr_t)ia & ~0x00000FFF);
>        regs->aim = (uintptr_t)regs->aip ^ (uintptr_t)regs->aiv.F.L.F;
>        if (__builtin_expect((!regs->tracing && !regs->permode),1))
>            regs->aie = regs->aip + pagesz - 5;
>        else
>        {
>            regs->aie = (BYTE *)1;
>            if (regs->tracing)
>                s390_process_trace(regs);
>        }
>    }
>
>    return dest;
>
>}
># 852 "vstore.h"
>static inline void s390_move_chars (U32 addr1, int arn1,
>       BYTE key1, U32 addr2, int arn2, BYTE key2, int len, REGS *regs)
>{
>BYTE *dest1, *dest2;
>BYTE *source1, *source2;
>BYTE *sk1, *sk2;
>int len2, len3;
>
>    ;
>
>
>    if (__builtin_expect((len == 0),0))
>    {
>        source1 = ( __builtin_expect((((regs))->aea_ar[((arn2))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn2))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr2)) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn2))]] & ((regs))->tlb.common[(((U32)((addr2)) >> 12) & 0x3FF)])),1) && __builtin_expect((((key2)) == 0 || ((key2)) == ((regs))->tlb.skey[(((U32)((addr2)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr2)) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr2)) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr2)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr2)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr2)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr2)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr2)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr2)))) ) : ( s390_logical_to_main_l (((addr2)), ((arn2)), ((regs)), ((0x0004)), ((key2)), (1)) ) );
>        dest1 = ( __builtin_expect((((regs))->aea_ar[((arn1))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn1))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr1)) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn1))]] & ((regs))->tlb.common[(((U32)((addr1)) >> 12) & 0x3FF)])),1) && __builtin_expect((((key1)) == 0 || ((key1)) == ((regs))->tlb.skey[(((U32)((addr1)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr1)) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr1)) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0002)) & ((regs))->tlb.acc[(((U32)((addr1)) >> 12) & 0x3FF)]),1) ? ( (((0x0002)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr1)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr1)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr1)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr1)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr1)))) ) : ( s390_logical_to_main_l (((addr1)), ((arn1)), ((regs)), ((0x0002)), ((key1)), (1)) ) );
>        *dest1 = *source1;
>        ;
>        return;
>    }
>
>
>    source1 = ( __builtin_expect((((regs))->aea_ar[((arn2))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn2))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr2)) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn2))]] & ((regs))->tlb.common[(((U32)((addr2)) >> 12) & 0x3FF)])),1) && __builtin_expect((((key2)) == 0 || ((key2)) == ((regs))->tlb.skey[(((U32)((addr2)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr2)) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr2)) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr2)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr2)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr2)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr2)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr2)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr2)))) ) : ( s390_logical_to_main_l (((addr2)), ((arn2)), ((regs)), ((0x0004)), ((key2)), (1)) ) );
>    dest1 = ( __builtin_expect(((regs)->aea_ar[(arn1)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn1)])].F.L.F == (regs)->tlb.asd[((((U32)(addr1) >> 12) & 0x3FF))].F.L.F) || ((regs)->aea_common[(regs)->aea_ar[(arn1)]] & (regs)->tlb.common[(((U32)(addr1) >> 12) & 0x3FF)])),1) && __builtin_expect(((key1) == 0 || (key1) == (regs)->tlb.skey[(((U32)(addr1) >> 12) & 0x3FF)]),1) && __builtin_expect(((((addr1) & 0x7FC00000) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr1) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect(((0x0001) & (regs)->tlb.acc[(((U32)(addr1) >> 12) & 0x3FF)]),1) ? ( ((0x0001) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr1) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr1) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr1))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr1) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr1))) ) : ( s390_logical_to_main_l ((addr1), (arn1), (regs), (0x0001), (key1), (len+1)) ) );
>    sk1 = regs->dat.storkey;
># 889 "vstore.h"
>    if ( __builtin_expect((( (int)((addr1) & 0x7FF)) <= ( 0x7FF - (len) )),1) )
>    {
>        if ( __builtin_expect((( (int)((addr2) & 0x7FF)) <= ( 0x7FF - (len) )),1) )
>        {
>
>            concpy (regs, dest1, source1, len + 1);
>        }
>        else
>        {
>
>            len2 = 0x800 - (addr2 & 0x7FF);
>            source2 = ( __builtin_expect((((regs))->aea_ar[((arn2))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn2))])].F.L.F == ((regs))->tlb.asd[((((U32)(((addr2 + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn2))]] & ((regs))->tlb.common[(((U32)(((addr2 + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)])),1) && __builtin_expect((((key2)) == 0 || ((key2)) == ((regs))->tlb.skey[(((U32)(((addr2 + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]),1) && __builtin_expect(((((((addr2 + len2) & ((regs)->psw.amask.F.L.F))) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr2 + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)(((addr2 + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr2 + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr2 + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr2 + len2) & ((regs)->psw.amask.F.L.F))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr2 + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr2 + len2) & ((regs)->psw.amask.F.L.F))))) ) : ( s390_logical_to_main_l ((((addr2 + len2) & ((regs)->psw.amask.F.L.F))), ((arn2)), ((regs)), ((0x0004)), ((key2)), (1)) ) )
>                                                             ;
>            concpy (regs, dest1, source1, len2);
>            concpy (regs, dest1 + len2, source2, len - len2 + 1);
>        }
>        *sk1 |= (0x04 | 0x02);
>    }
>    else
>    {
>
>        len2 = 0x800 - (addr1 & 0x7FF);
>        dest2 = ( __builtin_expect((((regs))->aea_ar[((arn1))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn1))])].F.L.F == ((regs))->tlb.asd[((((U32)(((addr1 + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn1))]] & ((regs))->tlb.common[(((U32)(((addr1 + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)])),1) && __builtin_expect((((key1)) == 0 || ((key1)) == ((regs))->tlb.skey[(((U32)(((addr1 + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]),1) && __builtin_expect(((((((addr1 + len2) & ((regs)->psw.amask.F.L.F))) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr1 + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0001)) & ((regs))->tlb.acc[(((U32)(((addr1 + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]),1) ? ( (((0x0001)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr1 + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr1 + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr1 + len2) & ((regs)->psw.amask.F.L.F))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr1 + len2) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr1 + len2) & ((regs)->psw.amask.F.L.F))))) ) : ( s390_logical_to_main_l ((((addr1 + len2) & ((regs)->psw.amask.F.L.F))), ((arn1)), ((regs)), ((0x0001)), ((key1)), (1)) ) )
>                                                           ;
>        sk2 = regs->dat.storkey;
>
>        if ( __builtin_expect((( (int)((addr2) & 0x7FF)) <= ( 0x7FF - (len) )),1) )
>        {
>
>             concpy (regs, dest1, source1, len2);
>             concpy (regs, dest2, source1 + len2, len - len2 + 1);
>        }
>        else
>        {
>
>            len3 = 0x800 - (addr2 & 0x7FF);
>            source2 = ( __builtin_expect((((regs))->aea_ar[((arn2))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn2))])].F.L.F == ((regs))->tlb.asd[((((U32)(((addr2 + len3) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn2))]] & ((regs))->tlb.common[(((U32)(((addr2 + len3) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)])),1) && __builtin_expect((((key2)) == 0 || ((key2)) == ((regs))->tlb.skey[(((U32)(((addr2 + len3) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]),1) && __builtin_expect(((((((addr2 + len3) & ((regs)->psw.amask.F.L.F))) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr2 + len3) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)(((addr2 + len3) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr2 + len3) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr2 + len3) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr2 + len3) & ((regs)->psw.amask.F.L.F))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr2 + len3) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr2 + len3) & ((regs)->psw.amask.F.L.F))))) ) : ( s390_logical_to_main_l ((((addr2 + len3) & ((regs)->psw.amask.F.L.F))), ((arn2)), ((regs)), ((0x0004)), ((key2)), (1)) ) )
>                                                            ;
>            if (len2 == len3)
>            {
>
>                concpy (regs, dest1, source1, len2);
>                concpy (regs, dest2, source2, len - len2 + 1);
>            }
>            else if (len2 < len3)
>            {
>
>                concpy (regs, dest1, source1, len2);
>                concpy (regs, dest2, source1 + len2, len3 - len2);
>                concpy (regs, dest2 + len3 - len2, source2, len - len3 + 1);
>            }
>            else
>            {
>
>                concpy (regs, dest1, source1, len3);
>                concpy (regs, dest1 + len3, source2, len2 - len3);
>                concpy (regs, dest2, source2 + len2 - len3, len - len2 + 1);
>            }
>        }
>        *sk1 |= (0x04 | 0x02);
>        *sk2 |= (0x04 | 0x02);
>    }
>    ;
>
>}
># 1073 "vstore.h"
>static inline void s390_validate_operand (U32 addr, int arn,
>                                      int len, int acctype, REGS *regs)
>{
>
>    ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((acctype)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((acctype)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( s390_logical_to_main_l (((addr)), ((arn)), ((regs)), ((acctype)), ((regs->psw.pkey)), (1)) ) );
>
>
>    if ( __builtin_expect((( (int)((addr) & 0x7FF)) > ( 0x7FF - (len) )),0) )
>    {
>        ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].F.L.F == ((regs))->tlb.asd[((((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF))].F.L.F) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]),1) && __builtin_expect(((((((addr + len) & ((regs)->psw.amask.F.L.F))) & 0x7FC00000) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF))].F.L.F),1) && __builtin_expect((((acctype)) & ((regs))->tlb.acc[(((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]),1) ? ( (((acctype)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + len) & ((regs)->psw.amask.F.L.F))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len) & ((regs)->psw.amask.F.L.F))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + len) & ((regs)->psw.amask.F.L.F))))) ) : ( s390_logical_to_main_l ((((addr + len) & ((regs)->psw.amask.F.L.F))), ((arn)), ((regs)), ((acctype)), ((regs->psw.pkey)), (1)) ) )
>                                                  ;
>    }
>
>
>
>
>}
># 737 "inline.h" 2
># 43 "cpu.c" 2
>
>
>
>
>
>void s390_checkstop_cpu(REGS *regs)
>{
>    regs->cpustate=2;
>    regs->checkstop=1;
>    do { (regs)->ints_state |= ( 1 << (31) ); } while (0);
>}
>
>
>
>void s390_checkstop_config(void)
>{
>    int i;
>    for(i=0;i<sysblk.maxcpu;i++)
>    {
>        if((sysblk.regs[(i)] != ((void *)0)))
>        {
>            s390_checkstop_cpu(sysblk.regs[i]);
>        }
>    }
>    do { int i; CPU_BITMAP mask = (sysblk.waiting_mask); for (i = 0; mask; i++) { if (mask & 1) ptt_pthread_cond_signal((&sysblk.regs[i]->intcond),"cpu.c" ":" "67"); mask >>= 1; } } while (0);
>}
>
>
>
>
>void s390_store_psw (REGS *regs, BYTE *addr)
>{
>
>
>    if (!regs->psw.zeroilc)
>        do { if ((regs)->aie) (regs)->psw.ia.F.L.F = ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((0))) & ((((regs)))->psw.amask.F.L.F)); } while (0);
>
>
>
>
>
>        store_fw_noswap((addr), __bswap_32 ((( (regs->psw.sysmask << 24) | ((regs->psw.pkey | regs->psw.states) << 16) | ( ( (regs->psw.asc) | (regs->psw.cc << 4) | (regs->psw.progmask) ) << 8 ) | regs->psw.zerobyte ))))
># 94 "cpu.c"
>                  ;
>        if(__builtin_expect((regs->psw.zeroilc),0))
>            store_fw_noswap((addr + 4), __bswap_32 ((regs->psw.ia.F.L.F | (regs->psw.amode ? 0x80000000 : 0))));
>        else
>            store_fw_noswap((addr + 4), __bswap_32 ((( (regs->psw.ia.F.L.F & ((regs)->psw.amask.F.L.F)) | (regs->psw.amode ? 0x80000000 : 0) ))))
>
>                  ;
># 147 "cpu.c"
>}
>
>
>
>
>
>int s390_load_psw (REGS *regs, BYTE *addr)
>{
>    do { if ((regs)->aie) { (regs)->psw.ia.F.L.F = ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((0))) & ((((regs)))->psw.amask.F.L.F)); (regs)->aie = ((void *)0); } } while (0);
>
>    regs->psw.zeroilc = 1;
>
>    regs->psw.sysmask = addr[0];
>    regs->psw.pkey = (addr[1] & 0xF0);
>    regs->psw.states = (addr[1] & 0x0F);
>
>
>
>
>
>        do { (regs)->ints_mask = ( ( ( ( 1 << (31) ) | ( 1 << (1) ) | ( 1 << (3) ) ) ) | ( (((regs))->psw.sysmask & 0x02) ? ( 1 << (30) ) : 0 ) | ( (((&((regs))->psw)->states & ( 1 << (2) )) != 0) ? (((regs))->cr[(14)].F.L.F & ( ( 1 << (28) ) | ( 1 << (27) ) | ( 1 << (26) ) | ( 1 << (25) ) | ( 1 << (24) ) )) : 0 ) | ( ( ((((regs)))->psw.sysmask & 0x40) || (__builtin_expect((((((regs))))->sie_mode),0) && ((((regs)))->siebk->m & 0x01)) ) ? (((regs))->ints_mask & ( ( 1 << (23) ) | ( 1 << (22) ) | ( 1 << (21) ) | ( 1 << (20) ) | ( 1 << (19) ) | ( 1 << (16) ) )) : 0 ) | ( (((regs))->psw.sysmask & 0x01) ? (( (((regs)))->cr[(0)].F.L.F & ( ( 1 << (15) ) | ( 1 << (14) ) | ( 1 << (13) ) | ( 1 << (12) ) | ( 1 << (11) ) | ( 1 << (10) ) | ( 1 << (9) ) | ( 1 << (7) ) | ( 1 << (6) ) | ( 1 << (5) ) | ( 1 << (4) ) ))) : 0 ) | ( (((&((regs))->psw)->states & ( 1 << (1) )) != 0) ? ( 1 << (0) ) : 0 ) ); if ( ( (regs)->permode = ( (((regs))->psw.sysmask & 0x40) || (__builtin_expect(((((regs)))->sie_mode),0) && (((regs))->siebk->m & 0x01)) ) ) ) do { if (((regs))->aie) { ((regs))->psw.ia.F.L.F = ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((0))) & (((((regs))))->psw.amask.F.L.F)); ((regs))->aie = ((void *)0); } } while (0); } while (0);
>
>
>        regs->psw.intcode = 0;
>        regs->psw.asc = (addr[2] & 0xC0);
>        regs->psw.cc = (addr[2] & 0x30) >> 4;
>        regs->psw.progmask = (addr[2] & 0x0F);
>        regs->psw.amode = (addr[4] & 0x80) ? 1 : 0;
># 184 "cpu.c"
>        regs->psw.zerobyte = addr[3];
>        regs->psw.amode64 = 0;
>        regs->psw.ia.F.L.F = __bswap_32 (fetch_fw_noswap((addr + 4))) & 0x7FFFFFFF;
>        regs->psw.amask.F.L.F = regs->psw.amode ? 0x7FFFFFFF : 0x00FFFFFF;
>
>
>
>        if ((addr[0] & 0xB8) != 0)
>            return 0x0006;
># 208 "cpu.c"
>        if ( regs->psw.zerobyte )
>            return 0x0006;
>
>
>        if (!(((&regs->psw)->states & ( 1 << (3) )) != 0))
>            return 0x0006;
># 245 "cpu.c"
>        if (!regs->psw.amode && regs->psw.ia.F.L.F > 0x00FFFFFF)
>            return 0x0006;
># 276 "cpu.c"
>    if( (__builtin_expect((((regs))->sie_mode),0) && ((((regs))->siebk->mx) & (0x01)) )
>      && ( (regs->psw.sysmask & 0x04) || (((&regs->psw)->asc & ( 1 << (7) )) != 0)) )
>        return 0x0006;
>
>
>    regs->psw.zeroilc = 0;
>
>
>    if ((((&regs->psw)->states & ( 1 << (1) )) != 0) && ( (sysblk.insttrace && sysblk.traceaddr[0] == 0 && sysblk.traceaddr[1] == 0) || (sysblk.inststep && sysblk.stepaddr[0] == 0 && sysblk.stepaddr[1] == 0) ))
>    {
>        logmsg (("HHCCP043I Wait state PSW loaded: "));
>        display_psw (regs);
>    }
>
>    do { if ((regs)->aea_mode != ( ( (((&((regs))->psw)->sysmask & 0x04)==0) ? ((__builtin_expect((((((regs))))->sie_mode),0) && ((((((regs))))->siebk->mx) & (0x01)) ) && (((&((regs))->psw)->asc & ( 1 << (6) )) != 0) ? 2 : 0) : ((((regs))->psw.asc >> 6) + 1) ) | ( ( ((((regs)))->psw.sysmask & 0x40) || (__builtin_expect((((((regs))))->sie_mode),0) && ((((regs)))->siebk->m & 0x01)) ) ? 0x40 : 0 ) )) { do { int i; int inst_cr = ((regs))->aea_ar[20]; BYTE oldmode = ((regs))->aea_mode; ((regs))->aea_mode = ( ( (((&(((regs)))->psw)->sysmask & 0x04)==0) ? ((__builtin_expect(((((((regs)))))->sie_mode),0) && (((((((regs)))))->siebk->mx) & (0x01)) ) && (((&(((regs)))->psw)->asc & ( 1 << (6) )) != 0) ? 2 : 0) : (((((regs)))->psw.asc >> 6) + 1) ) | ( ( (((((regs))))->psw.sysmask & 0x40) || (__builtin_expect(((((((regs)))))->sie_mode),0) && (((((regs))))->siebk->m & 0x01)) ) ? 0x40 : 0 ) ); switch (((regs))->aea_mode & 0x0F) { case 1: ((regs))->aea_ar[20] = 1; for(i = 0; i < 16; i++) ((regs))->aea_ar[i] = 1; break; case 2: (((regs)))->aea_ar[20] = 1; for(i = 0; i < 16; i++) (((regs)))->aea_ar[i] = 1; for (i = 1; i < 16; i++) { if ((((regs)))->ar[(i)] == 1) (((regs)))->aea_ar[i] = 7; else if ((((regs)))->ar[(i)] != 0) (((regs)))->aea_ar[i] = 0; } break; case 3: (((regs)))->aea_ar[20] = 1; for(i = 0; i < 16; i++) (((regs)))->aea_ar[i] = 7; break; case 4: (((regs)))->aea_ar[20] = 13; for(i = 0; i < 16; i++) (((regs)))->aea_ar[i] = 13; break; default: ((regs))->aea_ar[20] = 32; for(i = 0; i < 16; i++) ((regs))->aea_ar[i] = 32; } if (inst_cr != ((regs))->aea_ar[20]) do { if ((((regs)))->aie) { (((regs)))->psw.ia.F.L.F = ((U32)((((((regs)))))->aiv.F.L.F + ((intptr_t)(((((regs)))))->ip - (intptr_t)(((((regs)))))->aip) + ((0))) & ((((((regs)))))->psw.amask.F.L.F)); (((regs)))->aie = ((void *)0); } } while (0); if ((oldmode & 0x40) == 0 && (((regs))->aea_mode & 0x40) != 0) { do { if ((((regs)))->aie) { (((regs)))->psw.ia.F.L.F = ((U32)((((((regs)))))->aiv.F.L.F + ((intptr_t)(((((regs)))))->ip - (intptr_t)(((((regs)))))->aip) + ((0))) & ((((((regs)))))->psw.amask.F.L.F)); (((regs)))->aie = ((void *)0); } } while (0); if (( __builtin_expect(((((regs)))->permode),0) && ((((regs)))->ints_state & ( 1 << (21) )) )) s390_invalidate_tlb(((regs)),~(0x0002|0x0001)); } } while (0); } } while (0);
>
>    return 0;
>}
>
>
>
>
>void (__attribute__ (( regparm(2) )) s390_program_interrupt) (REGS *regs, int pcode)
>{
>PSA_3XX *psa;
>REGS *realregs;
>U64 px;
>int code;
>int ilc;
># 314 "cpu.c"
>int sie_ilc=0;
>
>
>int nointercept;
>
>
>
>
>char dxcstr[8]={0};
>
>static char *pgmintname[] = {
>                        "Operation exception",
>                        "Privileged-operation exception",
>                        "Execute exception",
>                        "Protection exception",
>                        "Addressing exception",
>                        "Specification exception",
>                        "Data exception",
>                        "Fixed-point-overflow exception",
>                        "Fixed-point-divide exception",
>                        "Decimal-overflow exception",
>                        "Decimal-divide exception",
>                        "HFP-exponent-overflow exception",
>                        "HFP-exponent-underflow exception",
>                        "HFP-significance exception",
>                        "HFP-floating-point-divide exception",
>                        "Segment-translation exception",
>                        "Page-translation exception",
>                        "Translation-specification exception",
>                        "Special-operation exception",
>                        "Pseudo-page-fault exception",
>                        "Operand exception",
>                        "Trace-table exception",
>                        "ASN-translation exception",
>                        "Page access exception",
>                        "Vector/Crypto operation exception",
>                        "Page state exception",
>                        "Page transition exception",
>                        "Space-switch event",
>                        "Square-root exception",
>                        "Unnormalized-operand exception",
>                        "PC-translation specification exception",
>                        "AFX-translation exception",
>                        "ASX-translation exception",
>                        "LX-translation exception",
>                        "EX-translation exception",
>                        "Primary-authority exception",
>                        "Secondary-authority exception",
>                        "LFX-translation exception",
>                        "LSX-translation exception",
>                        "ALET-specification exception",
>                        "ALEN-translation exception",
>                        "ALE-sequence exception",
>                        "ASTE-validity exception",
>                        "ASTE-sequence exception",
>                        "Extended-authority exception",
>                        "LSTE-sequence exception",
>                        "ASTE-instance exception",
>                        "Stack-full exception",
>                        "Stack-empty exception",
>                        "Stack-specification exception",
>                        "Stack-type exception",
>                        "Stack-operation exception",
>                        "Unassigned exception",
>                        "Unassigned exception",
>                        "Unassigned exception",
>                        "ASCE-type exception",
>                        "Region-first-translation exception",
>                        "Region-second-translation exception",
>                        "Region-third-translation exception",
>                        "Unassigned exception",
>                        "Unassigned exception",
>                        "Unassigned exception",
>                        "Unassigned exception",
>                        "Monitor event" };
>
>
>
>
>
>
>
>    if(regs->ghostregs)
>        longjmp(regs->progjmp, pcode);
>
>    do { if (pttclass & (0x0400)) ptt_pthread_trace(0x0400,"*PROG",(void *)(uintptr_t)(pcode),(void *)(uintptr_t)((U32)(regs->ea.F.L.F & 0xffffffff)),"cpu.c" ":" "399",(int)(regs->psw.ia.F.L.F)); } while(0);
>
>
>
>
>
>
>        realregs = __builtin_expect(((regs)->sie_mode),0)
>                 ? sysblk.regs[regs->cpuad]->guestregs
>                 : sysblk.regs[regs->cpuad];
>
>
>
>
>
>    realregs->instcount++;
>
>
>    if (sysblk.intowner == realregs->cpuad)
>        do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "418"); } while (0);
>    if (sysblk.mainowner == realregs->cpuad)
>        do { if ((realregs)->sysblk->mainowner == (realregs)->hostregs->cpuad) { (realregs)->sysblk->mainowner = 0xFFFF; ptt_pthread_mutex_unlock((&(realregs)->sysblk->mainlock),"cpu.c" ":" "420"); } } while (0);
>
>
>    do { if ((realregs)->aie) { (realregs)->psw.ia.F.L.F = ((U32)((((realregs)))->aiv.F.L.F + ((intptr_t)(((realregs)))->ip - (intptr_t)(((realregs)))->aip) + ((0))) & ((((realregs)))->psw.amask.F.L.F)); (realregs)->aie = ((void *)0); } } while (0);
>
>    if(realregs->sie_active)
>        do { if ((realregs->guestregs)->aie) { (realregs->guestregs)->psw.ia.F.L.F = ((U32)((((realregs->guestregs)))->aiv.F.L.F + ((intptr_t)(((realregs->guestregs)))->ip - (intptr_t)(((realregs->guestregs)))->aip) + ((0))) & ((((realregs->guestregs)))->psw.amask.F.L.F)); (realregs->guestregs)->aie = ((void *)0); } } while (0);
>
>
>
>    ilc = realregs->psw.zeroilc ? 0 : (__builtin_expect((!(realregs)->execflag),1) ? (realregs)->psw.ilc : (realregs)->exrl ? 6 : 4);
>    if (realregs->psw.ilc == 0 && !realregs->psw.zeroilc)
>    {
>
>
>        ilc = realregs->execflag ? realregs->exrl ? 6 : 4 : 2;
>        realregs->ip += ilc;
>        realregs->psw.ia.F.L.F += ilc;
>        realregs->psw.ilc = ilc;
>    }
>
>    if(realregs->sie_active)
>    {
>        sie_ilc = realregs->guestregs->psw.zeroilc
>                ? 0 : (__builtin_expect((!(realregs->guestregs)->execflag),1) ? (realregs->guestregs)->psw.ilc : (realregs->guestregs)->exrl ? 6 : 4);
>        if (realregs->guestregs->psw.ilc == 0
>         && !realregs->guestregs->psw.zeroilc)
>        {
>            sie_ilc = realregs->guestregs->execflag ?
>                      realregs->guestregs->exrl ? 6 : 4 : 2;
>            realregs->guestregs->psw.ia.F.L.F += sie_ilc;
>            realregs->guestregs->psw.ilc = sie_ilc;
>        }
>    }
>
>
>
>    realregs->execflag = 0;
>
>    if(realregs->sie_active)
>        realregs->guestregs->execflag = 0;
>
>
>
>    if (realregs->cpuad == sysblk.mainowner)
>        do { if ((realregs)->sysblk->mainowner == (realregs)->hostregs->cpuad) { (realregs)->sysblk->mainowner = 0xFFFF; ptt_pthread_mutex_unlock((&(realregs)->sysblk->mainlock),"cpu.c" ":" "465"); } } while (0);
>
>
>
>
>
>    code = pcode & ~0x0080;
>
>
>
>    if( ( (realregs)->ints_state & (realregs)->ints_mask & ( ( 1 << (23) ) | ( 1 << (22) ) | ( 1 << (21) ) | ( 1 << (20) ) | ( 1 << (19) ) | ( 1 << (16) ) ) ) )
>        pcode |= 0x0080;
>
>
>    do { } while (0);
>    do { } while (0);
>
>
>
>
>    if(realregs->sie_active &&
>        (code == 0x0004
>      || code == 0x0005
>
>      || code == 0x0028
>      || code == 0x0029
>      || code == 0x002A
>      || code == 0x002D
>
>        ) )
>    {
>
>
>
>        realregs->guestregs->ea.F.L.F = realregs->ea.F.L.F;
>        realregs->guestregs->excarid = realregs->excarid;
>        realregs->guestregs->opndrid = realregs->opndrid;
>
>        realregs->guestregs->hostint = 1;
>
>        (realregs->guestregs->program_interrupt) (realregs->guestregs, pcode);
>    }
>
>
>
>
>    if ((code == 0x0011
>      || code == 0x0010
>
>
>
>
>
>
>      || code == 0x0016
>      || code == 0x0020
>      || code == 0x0021
>      || code == 0x0022
>      || code == 0x0026
>      || code == 0x0027
>      || code == 0x002E
>      || code == 0x0023
>      || code == 0x0024
>      || code == 0x0025
>      || code == 0x0029
>      || code == 0x002A
>      || code == 0x002B
>      || code == 0x002C
>      || code == 0x002F
>      || code == 0x002D
>      || code == 0x0030
>      || code == 0x0031
>      || code == 0x0032
>      || code == 0x0033
>      || code == 0x0034
>      || code == 0x0019)
>      && !realregs->instinvalid)
>    {
>        realregs->psw.ia.F.L.F -= ilc;
>        realregs->psw.ia.F.L.F &= ((realregs)->psw.amask.F.L.F);
>
>
>
>        if(realregs->sie_active && !realregs->guestregs->instinvalid)
>        {
>            realregs->guestregs->psw.ia.F.L.F -= sie_ilc;
>            realregs->guestregs->psw.ia.F.L.F &= ((realregs->guestregs)->psw.amask.F.L.F);
>        }
>
>    }
>
>
>
>    if(realregs->instinvalid &&
>      ( code == 0x0004
>      || code == 0x0005
>      || code == 0x0006
>      || code == 0x0012 ))
>    {
>        realregs->psw.ia.F.L.F += ilc;
>        realregs->psw.ia.F.L.F &= ((realregs)->psw.amask.F.L.F);
>    }
>
>
>    realregs->psw.intcode = pcode;
>
>
>    ((debug_program_interrupt) ? (debug_program_interrupt) ((regs),(pcode)) : (((void *)0)));
>
>
>    if(code && (( __builtin_expect(((realregs)->tracing),0) && (( sysblk.inststep && ( (sysblk.stepaddr[0] == 0 && sysblk.stepaddr[1] == 0) || (sysblk.stepaddr[0] <= sysblk.stepaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.F.L.F)) >= sysblk.stepaddr[0] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.F.L.F)) <= sysblk.stepaddr[1] ) || (sysblk.stepaddr[0] > sysblk.stepaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.F.L.F)) >= sysblk.stepaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.F.L.F)) <= sysblk.stepaddr[0] ) ) ) || ( sysblk.insttrace && ( (sysblk.traceaddr[0] == 0 && sysblk.traceaddr[1] == 0) || (sysblk.traceaddr[0] <= sysblk.traceaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.F.L.F)) >= sysblk.traceaddr[0] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.F.L.F)) <= sysblk.traceaddr[1] ) || (sysblk.traceaddr[0] > sysblk.traceaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.F.L.F)) >= sysblk.traceaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.F.L.F)) <= sysblk.traceaddr[0] ) ) )) )
>        || sysblk.pgminttr & ((U64)1 << ((code - 1) & 0x3F))))
>    {
>     BYTE *ip;
># 588 "cpu.c"
>        logmsg(("HHCCP014I "));
>
>        if(__builtin_expect(((realregs)->sie_mode),0))
>            logmsg(("SIE: "));
>
>
>
>
>        if (code == 0x0007)
>            sprintf(dxcstr, " DXC=%2.2X", regs->dxc);
>        logmsg (("CPU%4.4X: %s CODE=%4.4X ILC=%d%s\n"), realregs->cpuad,
>                pgmintname[ (code - 1) & 0x3F], pcode, ilc, dxcstr);
>
>
>        ip = realregs->instinvalid ? ((void *)0)
>           : (realregs->ip - ilc < realregs->aip)
>             ? realregs->inst : realregs->ip - ilc;
>
>        s390_display_inst (realregs, ip);
>    }
>
>    realregs->instinvalid = 0;
>
>
>
>    if(realregs->sie_active)
>        s390_sie_exit (realregs, (-3));
>
>
>
>    px = realregs->px.F.L.F;
>
>
>
>    if(__builtin_expect(((regs)->sie_mode),0))
>        px = regs->sie_px;
>
>
>
>    if(!__builtin_expect(((regs)->sie_mode),0) ||
>
>      (
>
>         !(code == 0x0004
>           && (!(((regs)->siebk->ec[2]) & (0x20))
>             || realregs->hostint))
>
>
>
>
>      && !((pcode & 0x0080) && (((regs)->siebk->m) & (0x01)))
>
>      && code != 0x0005
>      && code != 0x0006
>      && code != 0x0013
>
>
>
>
>      && !(code == 0x0029
>        && (((regs)->siebk->mx) & (0x01)))
>      && !(code == 0x002A
>        && (((regs)->siebk->mx) & (0x01)))
>      && !(code == 0x002D
>        && (((regs)->siebk->mx) & (0x01)))
>
>
>      && !(code == 0x0001
>        && (((regs)->siebk->ic[0]) & (0x80)))
>      && !(code == 0x0002
>        && (((regs)->siebk->ic[0]) & (0x40)))
>
>      && !(code == 0x0007
>        && (regs->dxc == 1 || regs->dxc == 2)
>        && (regs->cr[(0)].F.L.F & 0x00040000)
>        && !(regs->hostregs->cr[(0)].F.L.F & 0x00040000))
>
>
>      && !(((regs)->siebk->ic[0]) & (0x20)) )
>    )
>    {
>
>
>        (regs)->storkeys[(px)>>11] |= (0x04 | 0x02);
>
>
>        psa = (void*)(regs->mainstor + px);
># 683 "cpu.c"
>        nointercept = 1;
>    }
>    else
>    {
>
>
>
>        if(code != 0x0001)
>        {
>            psa = (void*)(regs->hostregs->mainstor + ((regs)->sie_state) + 0x40);
>
>            (regs->hostregs)->storkeys[(((regs)->sie_state))>>11] |= (0x04 | 0x02);
># 704 "cpu.c"
>        }
>        else
>        {
>
>            psa = (void*)(regs->mainstor + px);
>
>
>            (regs)->storkeys[(px)>>11] |= (0x04 | 0x02);
>        }
>
>        nointercept = 0;
>    }
>
>
>
>
>
>
>    if ( ( (realregs)->ints_mask & ( 1 << (21) ) ) && !( (realregs)->ints_mask & ( 1 << (19) ) ) &&
>                                   (realregs->ip[0] != 0x0E) &&
>         !(code == 0x00 || code == 0x06 || code == 0x08 || code == 0x0A ||
>           code == 0x0C || code == 0x0D || code == 0x0E || code == 0x1C ||
>           code == 0x40) )
>              do { (realregs)->ints_mask &= ~( 1 << (21) ); } while (0);
>
>    if( ( (realregs)->ints_state & (realregs)->ints_mask & ( ( 1 << (23) ) | ( 1 << (22) ) | ( 1 << (21) ) | ( 1 << (20) ) | ( 1 << (19) ) | ( 1 << (16) ) ) ) )
>    {
>        if( ( __builtin_expect(((realregs)->tracing),0) && (( sysblk.inststep && ( (sysblk.stepaddr[0] == 0 && sysblk.stepaddr[1] == 0) || (sysblk.stepaddr[0] <= sysblk.stepaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.F.L.F)) >= sysblk.stepaddr[0] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.F.L.F)) <= sysblk.stepaddr[1] ) || (sysblk.stepaddr[0] > sysblk.stepaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.F.L.F)) >= sysblk.stepaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.F.L.F)) <= sysblk.stepaddr[0] ) ) ) || ( sysblk.insttrace && ( (sysblk.traceaddr[0] == 0 && sysblk.traceaddr[1] == 0) || (sysblk.traceaddr[0] <= sysblk.traceaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.F.L.F)) >= sysblk.traceaddr[0] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.F.L.F)) <= sysblk.traceaddr[1] ) || (sysblk.traceaddr[0] > sysblk.traceaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.F.L.F)) >= sysblk.traceaddr[1] && ((U32)(((((realregs))))->aiv.F.L.F + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.F.L.F)) <= sysblk.traceaddr[0] ) ) )) ) )
>            logmsg(("HHCCP015I CPU%4.4X PER event: code=%4.4X perc=%2.2X " "addr=" "%8.8""""X" "\n")
>                                         ,
>              regs->cpuad, pcode, ( (realregs)->ints_mask & ( ( 1 << (23) ) | ( 1 << (22) ) | ( 1 << (21) ) | ( 1 << (20) ) | ( 1 << (19) ) | ( 1 << (16) ) ) ) >> 16,
>              (realregs->psw.ia.F.L.F - ilc) & ((realregs)->psw.amask.F.L.F) );
>
>        realregs->perc |= ( (realregs)->ints_state & (realregs)->ints_mask & ( ( 1 << (23) ) | ( 1 << (22) ) | ( 1 << (21) ) | ( 1 << (20) ) | ( 1 << (19) ) | ( 1 << (16) ) ) ) >> ((32 - 8) - 16);
>
>
>
>
>        if( !(( (realregs)->ints_state & (realregs)->ints_mask & ( 1 << (21) ) ))
>          || (( (realregs)->ints_state & (realregs)->ints_mask & ( 1 << (19) ) )) )
>            realregs->perc &= 0xFFFC;
>
>        store_hw_noswap((psa->perint), (__extension__ ({ unsigned short int __v, __x = (unsigned short int) ((realregs->perc)); if (__builtin_constant_p (__x)) __v = ((unsigned short int) ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8))); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })));
>
>        store_fw_noswap((psa->peradr), __bswap_32 ((realregs->peradr)));
>
>        if( ( (realregs)->ints_mask & ( 1 << (21) ) ) && ((&realregs->psw)->asc == 0x40) )
>            psa->perarid = realregs->peraid;
>
>
>
>        if(nointercept)
>            do { (realregs)->ints_mask &= ~( ( 1 << (23) ) | ( 1 << (22) ) | ( 1 << (21) ) | ( 1 << (20) ) | ( 1 << (19) ) | ( 1 << (16) ) ); } while (0);
>
>    }
>    else
>    {
>        pcode &= 0xFF7F;
>    }
>
>
>
>
>
>
>
>    {
>
>        psa->pgmint[0] = 0;
>        psa->pgmint[1] = ilc;
>        store_hw_noswap((psa->pgmint + 2), (__extension__ ({ unsigned short int __v, __x = (unsigned short int) ((pcode)); if (__builtin_constant_p (__x)) __v = ((unsigned short int) ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8))); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })));
>
>
>        if ( code == 0x0011
>          || code == 0x0010
>
>
>
>
>
>
>          || code == 0x0029
>          || code == 0x002A
>          || code == 0x002B
>          || code == 0x002C
>          || code == 0x002F
>          || code == 0x002D
>
>          || code == 0x0004
>
>           )
>        {
>            psa->excarid = regs->excarid;
>            if(regs->ea.F.L.F | 0x004)
>                psa->opndrid = regs->opndrid;
>            realregs->opndrid = 0;
>        }
># 834 "cpu.c"
>        if ( code == 0x0011
>          || code == 0x0010
>          || code == 0x0020
>          || code == 0x0021
>          || code == 0x0024
>          || code == 0x0025
>          || code == 0x001C
>          || code == 0x0022
>          || code == 0x0023
>
>          || code == 0x0004
>
>           )
>        {
>            store_fw_noswap((psa->tea), __bswap_32 ((regs->ea.F.L.F)));
>        }
>
>        realregs->ea.F.L.F = 0;
>
>
>        if (code == 0x0007)
>        {
>            store_fw_noswap((psa->tea), __bswap_32 ((regs->dxc)));
>
>
>            if(regs->cr[(0)].F.L.F & 0x00040000)
>            {
>                regs->fpc &= ~(0x0000FF00);
>                regs->fpc |= ((regs->dxc << 8)) & 0x0000FF00;
>            }
>
>        }
>
>
>        if (code == 0x0040)
>        {
>            store_hw_noswap((psa->monclass), (__extension__ ({ unsigned short int __v, __x = (unsigned short int) ((regs->monclass)); if (__builtin_constant_p (__x)) __v = ((unsigned short int) ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8))); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })));
># 892 "cpu.c"
>            store_fw_noswap((psa->moncode), __bswap_32 ((regs->mc.F.L.F)));
>
>        }
>
>
>
>
>
>
>
>    }
>
>
>    realregs->hostint = 0;
>
>
>
>    if(nointercept)
>    {
>
>
>
>
>
>        s390_store_psw (realregs, psa->pgmold);
>
>
>        if ( (code = s390_load_psw (realregs, psa->pgmnew)) )
>        {
>
>            if(__builtin_expect(((realregs)->sie_mode),0))
>            {
>
>                longjmp(realregs->progjmp, pcode);
>            }
>            else
>
>            {
>                logmsg (("HHCCP016I CPU%4.4X: Program interrupt loop: "),
>                          realregs->cpuad);
>                display_psw (realregs);
>                do { REGS *_regs = (realregs); if ((_regs)) (_regs)->hostregs->intwait = 1; ptt_pthread_mutex_lock((&sysblk.intlock),"cpu.c" ":" "933"); if ((_regs)) { while (sysblk.syncing) { sysblk.sync_mask &= ~(_regs)->hostregs->cpubit; if (!sysblk.sync_mask) ptt_pthread_cond_signal((&sysblk.sync_cond),"cpu.c" ":" "933"); ptt_pthread_cond_wait((&sysblk.sync_bc_cond),(&sysblk.intlock),"cpu.c" ":" "933"); } (_regs)->hostregs->intwait = 0; sysblk.intowner = (_regs)->hostregs->cpuad; } else sysblk.intowner = 0xFFFE; } while (0);
>                realregs->cpustate = 2;
>                do { (realregs)->ints_state |= ( 1 << (31) ); } while (0);
>                do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "936"); } while (0);
>            }
>        }
>
>
>
>        longjmp(realregs->progjmp, (-1));
>
>
>    }
>
>    longjmp (realregs->progjmp, pcode);
>
>
>}
>
>
>
>
>static void s390_restart_interrupt (REGS *regs)
>{
>int rc;
>PSA_3XX *psa;
>
>    do { if (pttclass & (0x0100)) ptt_pthread_trace(0x0100,"*RESTART",(void *)(uintptr_t)(regs->cpuad),(void *)(uintptr_t)(regs->cpustate),"cpu.c" ":" "960",(int)(regs->psw.ia.F.L.F)); } while(0);
>
>
>    (regs)->storkeys[(regs->px.F.L.F)>>11] |= (0x04 | 0x02);
>
>
>    regs->psw.intcode = 0;
>
>
>    psa = (PSA_3XX*)(regs->mainstor + regs->px.F.L.F);
>
>
>    s390_store_psw (regs, psa->iplccw1);
>
>
>    rc = s390_load_psw (regs, psa->iplpsw);
>
>    if ( rc == 0)
>    {
>        regs->opinterv = 0;
>        regs->cpustate = 1;
>    }
>
>    do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "983"); } while (0);
>
>    if ( rc )
>        regs->program_interrupt(regs, rc);
>
>    longjmp (regs->progjmp, (-10));
>}
>
>
>
>
>
>
>void s390_perform_io_interrupt (REGS *regs)
>{
>int rc;
>int icode;
>PSA_3XX *psa;
>U32 ioparm;
>U32 ioid;
>U32 iointid;
>U64 pfx;
>DBLWRD csw;
>
>
>    icode = s390_present_io_interrupt (regs, &ioid, &ioparm, &iointid, csw);
>
>
>    if (icode == 0) return;
>
>    do { if (pttclass & (0x4000)) ptt_pthread_trace(0x4000,"*IOINT",(void *)(uintptr_t)(ioid),(void *)(uintptr_t)(ioparm),"cpu.c" ":" "1013",(int)(iointid)); } while(0);
>
>
>    if(__builtin_expect(((regs)->sie_mode),0) && icode != (-1))
>    {
>
>        psa = (void*)(regs->hostregs->mainstor + ((regs)->sie_state) + 0x30);
>        (regs->hostregs)->storkeys[(((regs)->sie_state))>>11] |= (0x04 | 0x02);
>    }
>    else
>
>    {
>
>        pfx =
>
>              __builtin_expect(((regs)->sie_mode),0) ? regs->sie_px :
>
>              regs->px.F.L.F;
>        psa = (void*)(regs->mainstor + pfx);
>        (regs)->storkeys[(pfx)>>11] |= (0x04 | 0x02);
>    }
># 1057 "cpu.c"
>    store_fw_noswap((psa->ioid), __bswap_32 ((ioid)));
>
>
>    store_fw_noswap((psa->ioparm), __bswap_32 ((ioparm)));
>
>
>
>    store_fw_noswap((psa->iointid), __bswap_32 ((iointid)));
>
>
>
>    if (( __builtin_expect(((regs)->tracing),0) && (( sysblk.inststep && ( (sysblk.stepaddr[0] == 0 && sysblk.stepaddr[1] == 0) || (sysblk.stepaddr[0] <= sysblk.stepaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.F.L.F)) >= sysblk.stepaddr[0] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.F.L.F)) <= sysblk.stepaddr[1] ) || (sysblk.stepaddr[0] > sysblk.stepaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.F.L.F)) >= sysblk.stepaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.F.L.F)) <= sysblk.stepaddr[0] ) ) ) || ( sysblk.insttrace && ( (sysblk.traceaddr[0] == 0 && sysblk.traceaddr[1] == 0) || (sysblk.traceaddr[0] <= sysblk.traceaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.F.L.F)) >= sysblk.traceaddr[0] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.F.L.F)) <= sysblk.traceaddr[1] ) || (sysblk.traceaddr[0] > sysblk.traceaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.F.L.F)) >= sysblk.traceaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.F.L.F)) <= sysblk.traceaddr[0] ) ) )) ))
>
>
>
>
>        logmsg (("HHCCP046I I/O interrupt code=%8.8X parm=%8.8X id=%8.8X\n"),
>          ioid, ioparm, iointid);
>
>
>
>
>    if(icode == (-1))
>
>    {
>
>        s390_store_psw ( regs, psa->iopold );
>
>
>        rc = s390_load_psw ( regs, psa->iopnew );
>
>        if ( rc )
>        {
>            do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1090"); } while (0);
>            regs->program_interrupt (regs, rc);
>        }
>    }
>
>    do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1095"); } while (0);
>
>    longjmp(regs->progjmp, icode);
>
>}
>
>
>
>
>
>static void s390_perform_mck_interrupt (REGS *regs)
>{
>int rc;
>PSA_3XX *psa;
>U64 mcic;
>U32 xdmg;
>U64 fsta;
>
>
>    rc = s390_present_mck_interrupt (regs, &mcic, &xdmg, &fsta);
>
>
>    if (rc == 0) return;
>
>
>    (regs)->storkeys[(regs->px.F.L.F)>>11] |= (0x04 | 0x02);
>
>
>    psa = (void*)(regs->mainstor + regs->px.F.L.F);
>
>
>    s390_store_status (regs, regs->px.F.L.F);
>
>
>
>
>    memset(psa->storepsw, 0, 16);
>
>
>
>    store_dw_i686_noswap((psa->mckint),__bswap_64 ((mcic)));
>
>
>    if (( __builtin_expect(((regs)->tracing),0) && (( sysblk.inststep && ( (sysblk.stepaddr[0] == 0 && sysblk.stepaddr[1] == 0) || (sysblk.stepaddr[0] <= sysblk.stepaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.F.L.F)) >= sysblk.stepaddr[0] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.F.L.F)) <= sysblk.stepaddr[1] ) || (sysblk.stepaddr[0] > sysblk.stepaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.F.L.F)) >= sysblk.stepaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.F.L.F)) <= sysblk.stepaddr[0] ) ) ) || ( sysblk.insttrace && ( (sysblk.traceaddr[0] == 0 && sysblk.traceaddr[1] == 0) || (sysblk.traceaddr[0] <= sysblk.traceaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.F.L.F)) >= sysblk.traceaddr[0] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.F.L.F)) <= sysblk.traceaddr[1] ) || (sysblk.traceaddr[0] > sysblk.traceaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.F.L.F)) >= sysblk.traceaddr[1] && ((U32)(((((regs))))->aiv.F.L.F + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.F.L.F)) <= sysblk.traceaddr[0] ) ) )) ))
>        logmsg (("HHCCP022I Machine Check code=%16.16" "ll" "u\n"),
>                  (long long)mcic);
>
>
>    store_fw_noswap((psa->xdmgcode), __bswap_32 ((xdmg)));
>
>
>
>
>
>
>    store_fw_noswap((psa->mcstorad), __bswap_32 ((fsta)));
>
>
>
>    s390_store_psw ( regs, psa->mckold );
>
>
>    rc = s390_load_psw ( regs, psa->mcknew );
>
>    do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1159"); } while (0);
>
>    if ( rc )
>        regs->program_interrupt (regs, rc);
>
>    longjmp (regs->progjmp, (-11));
>}
># 1411 "cpu.c"
>void (__attribute__ (( regparm(1) )) s390_process_interrupt)(REGS *regs)
>{
>
>    if( ( (regs)->ints_state & (regs)->ints_mask & ( ( 1 << (23) ) | ( 1 << (22) ) | ( 1 << (21) ) | ( 1 << (20) ) | ( 1 << (19) ) | ( 1 << (16) ) ) ) )
>        regs->program_interrupt (regs, 0x0080);
>
>
>    do { REGS *_regs = (regs); if ((_regs)) (_regs)->hostregs->intwait = 1; ptt_pthread_mutex_lock((&sysblk.intlock),"cpu.c" ":" "1418"); if ((_regs)) { while (sysblk.syncing) { sysblk.sync_mask &= ~(_regs)->hostregs->cpubit; if (!sysblk.sync_mask) ptt_pthread_cond_signal((&sysblk.sync_cond),"cpu.c" ":" "1418"); ptt_pthread_cond_wait((&sysblk.sync_bc_cond),(&sysblk.intlock),"cpu.c" ":" "1418"); } (_regs)->hostregs->intwait = 0; sysblk.intowner = (_regs)->hostregs->cpuad; } else sysblk.intowner = 0xFFFE; } while (0);
>    do { (regs)->ints_state &= ~( 1 << (31) ); } while (0);
>    regs->tracing = (sysblk.inststep || sysblk.insttrace);
>
>
>    do { if ((regs)->aie) { (regs)->psw.ia.F.L.F = ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((0))) & ((((regs)))->psw.amask.F.L.F)); (regs)->aie = ((void *)0); } } while (0);
>
>
>    if (__builtin_expect((regs->invalidate),0))
>        s390_invalidate_tlbe(regs, regs->invalidate_main);
>
>
>    if (__builtin_expect((regs->cpustate == 1),1))
>    {
>
>        if ( ( (regs)->ints_state & (regs)->ints_mask & ( ( 1 << (28) ) | ( 1 << (27) ) | ( 1 << (26) ) | ( 1 << (25) ) | ( 1 << (24) ) ) ) )
>        {
>            do { } while (0);
>            do { } while (0);
>            s390_perform_mck_interrupt (regs);
>        }
>
>
>        if ( ( (regs)->ints_state & (regs)->ints_mask & ( ( 1 << (15) ) | ( 1 << (14) ) | ( 1 << (13) ) | ( 1 << (12) ) | ( 1 << (11) ) | ( 1 << (10) ) | ( 1 << (9) ) | ( 1 << (8) ) | ( 1 << (7) ) | ( 1 << (6) ) | ( 1 << (5) ) | ( 1 << (4) ) ) ) )
>        {
>            do { } while (0);
>            do { } while (0);
>            s390_perform_external_interrupt (regs);
>        }
>
>
>        if (( sysblk.ints_state & ( 1 << (30) ) ))
>        {
>            if ( ( (regs)->ints_state & (regs)->ints_mask & ( ( 1 << (30) ) ) ) )
>            {
>                do { } while (0);
>                do { } while (0);
>                s390_perform_io_interrupt (regs);
>            }
>            else
>                do { int i; CPU_BITMAP mask = (sysblk.waiting_mask); for (i = 0; mask; i++) { if (mask & 1) { ptt_pthread_cond_signal((&sysblk.regs[i]->intcond),"cpu.c" ":" "1458"); break; } mask >>= 1; } } while (0);
>        }
>    }
>
>
>    if (__builtin_expect((regs->cpustate == 2),0))
>    {
>
>        regs->opinterv = 0;
>        regs->cpustate = 3;
>
>
>        if (!regs->configured)
>            longjmp(regs->exitjmp, (-1));
>
>
>        if (regs->sigpireset)
>        {
>            do { } while (0);
>            do { } while (0);
>            s390_initial_cpu_reset (regs);
>            do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1479"); } while (0);
>            longjmp(regs->progjmp, (-1));
>        }
>
>
>        if (regs->sigpreset)
>        {
>            do { } while (0);
>            do { } while (0);
>            s390_cpu_reset (regs);
>            do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1489"); } while (0);
>            longjmp(regs->progjmp, (-1));
>        }
>
>
>        if (( (regs)->ints_state & ( 1 << (3) ) ))
>        {
>            do { (regs)->ints_state &= ~( 1 << (3) ); } while (0);
>            s390_store_status (regs, 0);
>            logmsg (("HHCCP010I CPU%4.4X store status completed.\n"),
>                    regs->cpuad);
>
>
>
>
>
>
>
>        }
>    }
>
>
>    if ( ( (regs)->ints_state & ( 1 << (1) ) ) )
>    {
>        do { } while (0);
>        do { } while (0);
>        do { (regs)->ints_state &= ~( 1 << (1) ); } while (0);
>        s390_restart_interrupt (regs);
>    }
>
>
>    if (__builtin_expect((regs->cpustate == 3),0))
>    {
>        S64 saved_timer = cpu_timer(regs);
>        regs->ints_state = ( 1 << (0) );
>        sysblk.started_mask ^= regs->cpubit;
>        sysblk.intowner = 0xFFFF;
>
>
>        ptt_pthread_cond_wait((&regs->intcond),(&sysblk.intlock),"cpu.c" ":" "1528");
>
>
>        while (sysblk.syncing)
>            ptt_pthread_cond_wait((&sysblk.sync_bc_cond),(&sysblk.intlock),"cpu.c" ":" "1532");
>
>        sysblk.intowner = regs->cpuad;
>        sysblk.started_mask |= regs->cpubit;
>        regs->ints_state |= sysblk.ints_state;
>        set_cpu_timer(regs,saved_timer);
>
>        do { (regs)->ints_state |= ( 1 << (31) ); } while (0);
>
>
>        s390_purge_tlb (regs);
>
>        s390_purge_alb (regs);
>
>
>
>        if(sysblk.arch_mode != regs->arch_mode)
>            longjmp(regs->archjmp,(-1));
>
>        do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1551"); } while (0);
>        longjmp(regs->progjmp, (-1));
>    }
>
>
>    if ((((&regs->psw)->states & ( 1 << (1) )) != 0))
>    {
>
>        regs->waittod = host_tod();
>
>
>
>        if( ( ((regs)->ints_mask & ( ( ( 1 << (28) ) | ( 1 << (27) ) | ( 1 << (26) ) | ( 1 << (25) ) | ( 1 << (24) ) ) | ( ( 1 << (15) ) | ( 1 << (14) ) | ( 1 << (13) ) | ( 1 << (12) ) | ( 1 << (11) ) | ( 1 << (10) ) | ( 1 << (9) ) | ( 1 << (8) ) | ( 1 << (7) ) | ( 1 << (6) ) | ( 1 << (5) ) | ( 1 << (4) ) ) | ( ( 1 << (30) ) ) )) == 0 ) )
>        {
>            logmsg (("HHCCP011I CPU%4.4X: Disabled wait state\n" "          ")
>                                   ,
>                    regs->cpuad);
>            display_psw (regs);
>            regs->cpustate = 2;
>            do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1570"); } while (0);
>            longjmp(regs->progjmp, (-1));
>        }
>
>
>        sysblk.intowner = 0xFFFF;
>        sysblk.waiting_mask |= regs->cpubit;
>
>
>        ptt_pthread_cond_wait((&regs->intcond),(&sysblk.intlock),"cpu.c" ":" "1579");
>
>
>        while (sysblk.syncing)
>            ptt_pthread_cond_wait((&sysblk.sync_bc_cond),(&sysblk.intlock),"cpu.c" ":" "1583");
>
>
>        sysblk.waiting_mask ^= regs->cpubit;
>        sysblk.intowner = regs->cpuad;
>
>
>
>        regs->waittime += host_tod() - regs->waittod;
>        regs->waittod = 0;
>
>        do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1594"); } while (0);
>        longjmp(regs->progjmp, (-1));
>    }
>
>
>    do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1599"); } while (0);
>    return;
>
>}
>
>
>
>
>REGS *s390_run_cpu (int cpu, REGS *oldregs)
>{
>BYTE *ip;
>REGS regs;
>
>    if (oldregs)
>    {
>        memcpy (&regs, oldregs, sizeof(REGS));
>        free (oldregs);
>        regs.hostregs = &regs;
>        if (regs.guestregs)
>            regs.guestregs->hostregs = &regs;
>        sysblk.regs[cpu] = &regs;
>        ptt_pthread_mutex_unlock((&sysblk.cpulock[cpu]),"cpu.c" ":" "1620");
>        logmsg (("HHCCP007I CPU%4.4X architecture mode set to %s\n"),
>                cpu, get_arch_mode_string(&regs));
>    }
>    else
>    {
>        memset (&regs, 0, sizeof(REGS));
>
>        if (cpu_init (cpu, &regs, ((void *)0)))
>            return ((void *)0);
>
>        logmsg (("HHCCP003I CPU%4.4X architecture mode %s\n"),
>                cpu, get_arch_mode_string(&regs));
>
>
>
>
>
>
>    }
>
>    regs.program_interrupt = &s390_program_interrupt;
>
>    regs.trace_br = (func)&s390_trace_br;
>
>
>    regs.tracing = (sysblk.inststep || sysblk.insttrace);
>    regs.ints_state |= sysblk.ints_state;
>
>
>    if (_setjmp (regs.exitjmp))
>        return cpu_uninit(cpu, &regs);
>
>
>    _setjmp (regs.archjmp);
>
>
>    if(sysblk.arch_mode != regs.arch_mode)
>    {
>        do { if (pttclass & (0x0100)) ptt_pthread_trace(0x0100,"*SETARCH",(void *)(uintptr_t)(regs.arch_mode),(void *)(uintptr_t)(sysblk.arch_mode),"cpu.c" ":" "1659",(int)(cpu)); } while(0);
>        regs.arch_mode = sysblk.arch_mode;
>        oldregs = malloc (sizeof(REGS));
>        if (oldregs)
>        {
>            memcpy(oldregs, &regs, sizeof(REGS));
>            ptt_pthread_mutex_lock((&sysblk.cpulock[cpu]),"cpu.c" ":" "1665");
>        }
>        else
>        {
>            logmsg (("HHCCP080E CPU%4.4X malloc failed for archjmp regs: %s\n"),
>                    cpu, strerror((*__errno_location ())));
>            cpu_uninit (cpu, &regs);
>        }
>        return oldregs;
>    }
>
>    do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1676"); } while (0);
>
>
>    _setjmp (regs.progjmp);
>
>
>    regs.execflag = 0;
>
>    do {
>        if (( ((&regs))->ints_state & ((&regs))->ints_mask ))
>            s390_process_interrupt(&regs);
>
>        ip = __builtin_expect((( ( !((0)) && ((&regs))->ip < ((&regs))->aie ) || ( ((0)) && (((&regs))->et.F.L.F & (0x7FFFF000|0x01)) == ((&regs))->aiv.F.L.F && ((BYTE *)((uintptr_t)(((&regs)))->aip | (uintptr_t)((((&regs))->et.F.L.F) & 0x00000FFF))) < ((&regs))->aie ) )),1) ? ((0) ? ((BYTE *)((uintptr_t)((&regs))->aip | (uintptr_t)(((&regs)->et.F.L.F) & 0x00000FFF))) : (&regs)->ip) : s390_instfetch ((&regs), (0));
>        regs.instcount++;
>        do { ; ; (&regs)->s390_opcode_table[ip[0]]((ip), (&regs)); } while(0);
>
>        do {
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s390_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s390_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s390_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s390_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s390_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s390_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>
>            regs.instcount += 12;
>
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s390_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s390_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s390_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s390_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s390_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->s390_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>        } while (!( ((&regs))->ints_state & ((&regs))->ints_mask ));
>    } while (1);
>
>
>    return ((void *)0);
>
>}
>
>
>
>
>void s390_process_trace(REGS *regs)
>{
>int shouldtrace = 0;
>int shouldstep = 0;
>
>
>    if (( sysblk.insttrace && ( (sysblk.traceaddr[0] == 0 && sysblk.traceaddr[1] == 0) || (sysblk.traceaddr[0] <= sysblk.traceaddr[1] && ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & ((((regs)))->psw.amask.F.L.F)) >= sysblk.traceaddr[0] && ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & ((((regs)))->psw.amask.F.L.F)) <= sysblk.traceaddr[1] ) || (sysblk.traceaddr[0] > sysblk.traceaddr[1] && ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & ((((regs)))->psw.amask.F.L.F)) >= sysblk.traceaddr[1] && ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & ((((regs)))->psw.amask.F.L.F)) <= sysblk.traceaddr[0] ) ) ))
>        shouldtrace = 1;
>
>
>    if (( sysblk.inststep && ( (sysblk.stepaddr[0] == 0 && sysblk.stepaddr[1] == 0) || (sysblk.stepaddr[0] <= sysblk.stepaddr[1] && ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & ((((regs)))->psw.amask.F.L.F)) >= sysblk.stepaddr[0] && ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & ((((regs)))->psw.amask.F.L.F)) <= sysblk.stepaddr[1] ) || (sysblk.stepaddr[0] > sysblk.stepaddr[1] && ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & ((((regs)))->psw.amask.F.L.F)) >= sysblk.stepaddr[1] && ((U32)((((regs)))->aiv.F.L.F + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & ((((regs)))->psw.amask.F.L.F)) <= sysblk.stepaddr[0] ) ) ))
>        shouldstep = 1;
>
>
>    if (shouldtrace || shouldstep)
>    {
>        BYTE *ip = regs->ip < regs->aip ? regs->inst : regs->ip;
>        s390_display_inst (regs, ip);
>    }
>
>
>    if (shouldstep)
>    {
>        REGS *hostregs = regs->hostregs;
>        S64 saved_timer[2];
>
>        do { REGS *_regs = (hostregs); if ((_regs)) (_regs)->hostregs->intwait = 1; ptt_pthread_mutex_lock((&sysblk.intlock),"cpu.c" ":" "1745"); if ((_regs)) { while (sysblk.syncing) { sysblk.sync_mask &= ~(_regs)->hostregs->cpubit; if (!sysblk.sync_mask) ptt_pthread_cond_signal((&sysblk.sync_cond),"cpu.c" ":" "1745"); ptt_pthread_cond_wait((&sysblk.sync_bc_cond),(&sysblk.intlock),"cpu.c" ":" "1745"); } (_regs)->hostregs->intwait = 0; sysblk.intowner = (_regs)->hostregs->cpuad; } else sysblk.intowner = 0xFFFE; } while (0);
>
>        hostregs->waittod = host_tod();
>
>
>
>        saved_timer[0] = cpu_timer(regs);
>        saved_timer[1] = cpu_timer(hostregs);
>        hostregs->cpustate = 3;
>        sysblk.started_mask &= ~hostregs->cpubit;
>        hostregs->stepwait = 1;
>        sysblk.intowner = 0xFFFF;
>        while (hostregs->cpustate == 3)
>        {
>            ptt_pthread_cond_wait((&hostregs->intcond),(&sysblk.intlock),"cpu.c" ":" "1759");
>        }
>        sysblk.intowner = hostregs->cpuad;
>        hostregs->stepwait = 0;
>        sysblk.started_mask |= hostregs->cpubit;
>        set_cpu_timer(regs,saved_timer[0]);
>        set_cpu_timer(hostregs,saved_timer[1]);
>
>        hostregs->waittime += host_tod() - hostregs->waittod;
>        hostregs->waittod = 0;
>
>        do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1770"); } while (0);
>    }
>}
># 1791 "cpu.c"
>void s390_set_jump_pointers (REGS *regs, int jump)
>{
>
>
>
>
>    switch (jump) {
>
>
>    case 0xa7:
>jump_a7xx:
> __asm__ (
>        "movzbl 1(%%eax),%%ecx\n\t"
>        "jmp    *%c0(%%edx,%%ecx,4)"
>        : : "i" (__builtin_offsetof (REGS, s390_opcode_a7xx))
>        );
>        return;
>    case 0xb2:
>jump_b2xx:
> __asm__ (
>        "movzbl 1(%%eax),%%ecx\n\t"
>        "jmp    *%c0(%%edx,%%ecx,4)"
>        : : "i" (__builtin_offsetof (REGS, s390_opcode_b2xx))
>        );
>        return;
>    case 0xb9:
>jump_b9xx:
> __asm__ (
>        "movzbl 1(%%eax),%%ecx\n\t"
>        "jmp    *%c0(%%edx,%%ecx,4)"
>        : : "i" (__builtin_offsetof (REGS, s390_opcode_b9xx))
>        );
>        return;
>
>    case 0xc0:
>jump_c0xx:
> __asm__ (
>        "movzbl 1(%%eax),%%ecx\n\t"
>        "jmp    *%c0(%%edx,%%ecx,4)"
>        : : "i" (__builtin_offsetof (REGS, s390_opcode_c0xx))
>        );
>        return;
>    case 0xe3:
>jump_e3xx:
> __asm__ (
>        "movzbl 5(%%eax),%%ecx\n\t"
>        "jmp    *%c0(%%edx,%%ecx,4)"
>        : : "i" (__builtin_offsetof (REGS, s390_opcode_e3xx))
>        );
>        return;
>    case 0xeb:
>
>jump_ebxx:
> __asm__ (
>        "movzbl 5(%%eax),%%ecx\n\t"
>        "jmp    *%c0(%%edx,%%ecx,4)"
>        : : "i" (__builtin_offsetof (REGS, s390_opcode_ebxx))
>        );
>        return;
>
>
>    }
>
>    regs->s390_opcode_table[0xa7] = &&jump_a7xx;
>    regs->s390_opcode_table[0xb2] = &&jump_b2xx;
>    regs->s390_opcode_table[0xb9] = &&jump_b9xx;
>
>    regs->s390_opcode_table[0xc0] = &&jump_c0xx;
>    regs->s390_opcode_table[0xe3] = &&jump_e3xx;
>
>    regs->s390_opcode_table[0xeb] = &&jump_ebxx;
>
>
>
>
>
>
>}
># 1875 "cpu.c" 2
>
>
>
>
>
># 1 "cpu.c" 1
># 40 "cpu.c"
># 1 "hercules.h" 1
>
>
>
>
>
>
>
># 1 "./config.h" 1
># 9 "hercules.h" 2
># 47 "hercules.h"
># 1 "feature.h" 1
>
>
>
>
># 1 "./config.h" 1
># 6 "feature.h" 2
># 26 "feature.h"
># 1 "featall.h" 1
># 27 "feature.h" 2
>
>
>
>
>
>
># 1 "feat900.h" 1
># 34 "feature.h" 2
>
>
>
>
># 1 "featchk.h" 1
># 39 "feature.h" 2
># 48 "hercules.h" 2
>
>
>
>
>
># 1 "cpuint.h" 1
># 54 "hercules.h" 2
># 41 "cpu.c" 2
># 1 "opcode.h" 1
># 2736 "opcode.h"
>int z900_startio (REGS *regs, DEVBLK *dev, ORB *orb);
>void *s370_execute_ccw_chain (DEVBLK *dev);
>void *s390_execute_ccw_chain (DEVBLK *dev);
>void *z900_execute_ccw_chain (DEVBLK *dev);
>int stchan_id (REGS *regs, U16 chan);
>int testch (REGS *regs, U16 chan);
>int testio (REGS *regs, DEVBLK *dev, BYTE ibyte);
>int test_subchan (REGS *regs, DEVBLK *dev, IRB *irb);
>int cancel_subchan (REGS *regs, DEVBLK *dev);
>void clear_subchan (REGS *regs, DEVBLK *dev);
>int halt_subchan (REGS *regs, DEVBLK *dev);
>int haltio (REGS *regs, DEVBLK *dev, BYTE ibyte);
>int resume_subchan (REGS *regs, DEVBLK *dev);
>int z900_present_io_interrupt (REGS *regs, U32 *ioid,
>        U32 *ioparm, U32 *iointid, BYTE *csw);
>int z900_present_zone_io_interrupt (U32 *ioid, U32 *ioparm,
>                                              U32 *iointid, BYTE zone);
>void io_reset (void);
>int chp_reset(REGS *, BYTE chpid);
>void channelset_reset(REGS *regs);
> int device_attention (DEVBLK *dev, BYTE unitstat);
> int z900_device_attention (DEVBLK *dev, BYTE unitstat);
>
>
>
>
>
>
>void s370_store_psw (REGS *regs, BYTE *addr);
>int s370_load_psw (REGS *regs, BYTE *addr);
>void s370_process_trace (REGS *regs);
>
>
>int s390_load_psw (REGS *regs, BYTE *addr);
>void s390_store_psw (REGS *regs, BYTE *addr);
>void s390_process_trace (REGS *regs);
>
>
>int z900_load_psw (REGS *regs, BYTE *addr);
>void z900_store_psw (REGS *regs, BYTE *addr);
>void z900_process_trace (REGS *regs);
>
>
>int cpu_init (int cpu, REGS *regs, REGS *hostregs);
>void z900_perform_io_interrupt (REGS *regs);
>void z900_checkstop_config(void);
>
> void (__attribute__ (( regparm(2) )) s370_program_interrupt) (REGS *regs, int code);
>
>
> void (__attribute__ (( regparm(2) )) s390_program_interrupt) (REGS *regs, int code);
>
> void (__attribute__ (( regparm(2) )) z900_program_interrupt) (REGS *regs, int code);
>void *cpu_thread (int *cpu);
> void copy_psw (REGS *regs, BYTE *addr);
>void display_psw (REGS *regs);
>
>
>
>int z900_diag_devtype (int r1, int r2, REGS *regs);
>int z900_syncblk_io (int r1, int r2, REGS *regs);
>int z900_syncgen_io (int r1, int r2, REGS *regs);
>void z900_extid_call (int r1, int r2, REGS *regs);
>int z900_cpcmd_call (int r1, int r2, REGS *regs);
>void z900_pseudo_timer (U32 code, int r1, int r2, REGS *regs);
>void z900_access_reipl_data (int r1, int r2, REGS *regs);
>int z900_diag_ppagerel (int r1, int r2, REGS *regs);
>void z900_vm_info (int r1, int r2, REGS *regs);
>int z900_device_info (int r1, int r2, REGS *regs);
>
>
>
>int z900_vm_blockio (int r1, int r2, REGS *regs);
>
>
>
>void z900_load_real_address_proc (REGS *regs,
>    int r1, int b2, U64 effective_addr2);
>
>
>
>void packed_to_binary (BYTE *dec, int len, U64 *result,
>    int *ovf, int *dxf);
>void binary_to_packed (S64 bin, BYTE *result);
>
>
>
>void z900_diagnose_call (U64 effective_addr2, int b2, int r1, int r3,
>    REGS *regs);
>
>
>
>void z900_scpend_call (void);
>int z900_mssf_call (int r1, int r2, REGS *regs);
>void z900_diag204_call (int r1, int r2, REGS *regs);
>void z900_diag224_call (int r1, int r2, REGS *regs);
>
>
>
>void z900_perform_external_interrupt (REGS *regs);
>void z900_store_status (REGS *ssreg, U64 aaddr);
>void store_status (REGS *ssreg, U64 aaddr);
>
>
>
>int load_ipl (U16 lcss, U16 devnum, int cpu, int clear);
>int z900_load_ipl (U16 lcss, U16 devnum, int cpu, int clear);
>int system_reset (int cpu, int clear);
>int z900_system_reset (int cpu, int clear);
>int cpu_reset (REGS *regs);
>int z900_cpu_reset (REGS *regs);
>int initial_cpu_reset (REGS *regs);
>int z900_initial_cpu_reset (REGS *regs);
>int z900_common_load_begin (int cpu, int clear);
>int z900_common_load_finish (REGS *regs);
>void storage_clear(void);
>void xstorage_clear(void);
>
>
>
>void set_sce_dir (char *path);
>char *get_sce_dir ();
>int load_main (char *fname, U64 startloc);
>int z900_load_main (char *fname, U64 startloc);
>int load_hmc (char *fname, int cpu, int clear);
>int z900_load_hmc (char *fname, int cpu, int clear);
>void z900_sclp_scedio_request (SCCB_HEADER *);
>void z900_sclp_scedio_event (SCCB_HEADER *);
>
>
>
>int z900_present_mck_interrupt (REGS *regs, U64 *mcic, U32 *xdmg,
>    U64 *fsta);
>U32 channel_report (REGS *);
>void machine_check_crwpend (void);
>void z900_sync_mck_interrupt (REGS *regs);
>void sigabend_handler (int signo);
>
>
>
>extern void copy_opcode_tables ();
>void set_opcode_pointers (REGS *regs);
>
>
>
>void z900_display_inst (REGS *regs, BYTE *inst);
>void display_inst (REGS *regs, BYTE *inst);
>
>
>
>void z900_sie_exit (REGS *regs, int code);
>void z900_diagnose_002 (REGS *regs, int r1, int r3);
>
>
>
>void z900_trap_x (int trap_is_trap4, REGS *regs, U32 trap_operand);
>void z900_form_stack_entry (BYTE etype, U64 retna, U64 calla,
>    U32 csi, U32 pcnum, REGS *regs);
>U64 z900_locate_stack_entry (int prinst, LSED *lsedptr,
>    REGS *regs);
>void z900_stack_modify (U64 lsea, U32 m1, U32 m2, REGS *regs);
>void z900_stack_extract (U64 lsea, int r1, int code, REGS *regs);
>void z900_unstack_registers (int gtype, U64 lsea, int r1,
>    int r2, REGS *regs);
>int z900_program_return_unstack (REGS *regs, U64 *lsedap, int *rc);
>
>
>
>U64 z900_trace_br (int amode, U64 ia, REGS *regs);
>
>U32 s390_trace_br (int amode, U32 ia, REGS *regs);
>
>U64 z900_trace_bsg (U32 alet, U64 ia, REGS *regs);
>U64 z900_trace_ssar (int ssair, U16 sasn, REGS *regs);
>U64 z900_trace_pc (U32 pcea, REGS *regs);
>U64 z900_trace_pr (REGS *newregs, REGS *regs);
>U64 z900_trace_pt (int pti, U16 pasn, U64 gpr2, REGS *regs);
>U64 z900_trace_tr (int r1, int r3, U32 op, REGS *regs);
>U64 z900_trace_tg (int r1, int r3, U32 op, REGS *regs);
>U64 z900_trace_ms (int br_ind, U64 ia, REGS *regs);
>
>
>
>int z900_plo_cl (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>int z900_plo_clg (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>int z900_plo_clgr (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>int z900_plo_clx (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>int z900_plo_cs (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>int z900_plo_csg (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>int z900_plo_csgr (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>int z900_plo_csx (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>int z900_plo_dcs (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>int z900_plo_dcsg (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>int z900_plo_dcsgr (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>int z900_plo_dcsx (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>int z900_plo_csst (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>int z900_plo_csstg (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>int z900_plo_csstgr (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>int z900_plo_csstx (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>int z900_plo_csdst (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>int z900_plo_csdstg (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>int z900_plo_csdstgr (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>int z900_plo_csdstx (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>int z900_plo_cstst (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>int z900_plo_cststg (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>int z900_plo_cststgr (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>int z900_plo_cststx (int r1, int r3, U64 effective_addr2, int b2,
>                            U64 effective_addr4, int b4, REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) z900_execute_01xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_execute_a4xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_execute_a5xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_execute_a6xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_execute_a7xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_execute_b2xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_execute_b3xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_execute_b9xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_execute_c0xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_execute_e3xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_execute_e4xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_execute_e5xx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_execute_ebxx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_execute_ecxx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_execute_edxx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_operation_exception) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_dummy_instruction) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) z900_fix_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_svc_assist) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_obtain_local_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_release_local_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_obtain_cms_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_release_cms_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_trace_svc_interruption) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_trace_program_interruption) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_trace_initial_srb_dispatch) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_trace_io_interruption) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_trace_task_dispatch) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_trace_svc_return) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) z900_compression_call) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) z900_cipher_message_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_cipher_message_with_chaining_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compute_intermediate_message_digest_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compute_last_message_digest_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compute_message_authentication_code_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_perform_cryptographic_key_management_operation_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_cipher_message_with_cipher_feedback_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_cipher_message_with_counter_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_cipher_message_with_output_feedback_r) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_perform_cryptographic_computation_r) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) z900_branch_and_set_authority) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_in_subspace_group) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_and_stack) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_and_swap_and_purge) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_diagnose) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_extract_primary_asn) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_extract_primary_asn_and_instance) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_extract_secondary_asn) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_extract_secondary_asn_and_instance) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_extract_stacked_registers) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_extract_stacked_state) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_insert_address_space_control) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_insert_psw_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_insert_storage_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_insert_storage_key_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_insert_virtual_storage_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_invalidate_page_table_entry) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_address_space_parameters) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_control) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_program_status_word) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_real_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_using_real_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_lock_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_modify_stacked_state) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_move_to_primary) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_move_to_secondary) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_move_with_destination_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_move_with_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_move_with_optional_specifications) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_move_with_source_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_program_call) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_program_return) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_program_transfer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_program_transfer_with_instance) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_purge_accesslist_lookaside_buffer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_purge_translation_lookaside_buffer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_reset_reference_bit) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_reset_reference_bit_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_address_space_control) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_address_space_control_fast) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_clock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_clock_comparator) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_clock_programmable_field) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_cpu_timer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_prefix) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_psw_key_from_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_secondary_asn) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_secondary_asn_with_instance) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_storage_key) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_storage_key_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_system_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_signal_processor) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_clock_comparator) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_control) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_cpu_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_cpu_id) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_cpu_timer) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_prefix) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_system_information) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_then_and_system_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_then_or_system_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_using_real_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_access) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_block) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_protection) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_trace) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) z900_add_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_edit_x_edit_and_mark) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_shift_and_round_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_zero_and_add) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_decimal) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) z900_inter_user_communication_vehicle) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) z900_start_interpretive_execution) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_zone_parameter) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_zone_parameter) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_pending_zone_interrupt) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) z900_signal_adapter) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) z900_load_positive_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_negative_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_and_test_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_complement_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_halve_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_rounded_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_float_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_unnormal_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_unnormal_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_positive_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_negative_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_and_test_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_complement_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_halve_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_rounded_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_float_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_unnormal_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_unnormal_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_float_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_unnormal_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_unnormal_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_float_short_to_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_unnormal_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_unnormal_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_squareroot_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_squareroot_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_lengthened_float_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_lengthened_float_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_lengthened_float_short_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_squareroot_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_positive_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_negative_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_and_test_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_complement_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_rounded_float_ext_to_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_fp_int_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_fp_int_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_fp_int_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_fixed_to_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_fixed_to_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_fixed_to_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_fix64_to_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_fix64_to_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_fix64_to_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_float_short_to_fixed_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_float_long_to_fixed_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_float_ext_to_fixed_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_float_short_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_float_long_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_float_ext_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_lengthened_float_short_to_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_lengthened_float_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_lengthened_float_short_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_squareroot_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_squareroot_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_zero_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_zero_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_zero_float_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_add_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_add_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_add_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_add_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_subtract_float_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_subtract_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_subtract_float_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_subtract_float_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_unnormal_float_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_unnormal_float_long_to_ext_low_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_unnormal_float_long_to_ext_high_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_add_unnormal_float_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_add_unnormal_float_long_to_ext_low_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_add_unnormal_float_long_to_ext_high_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_unnormal_float_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_unnormal_float_long_to_ext_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_unnormal_float_long_to_ext_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_add_unnormal_float_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_add_unnormal_float_long_to_ext_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_add_unnormal_float_long_to_ext_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_float_long_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_float_short_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_float_long_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_float_short_y) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) z900_add_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_and_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_and) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_and_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_and_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_and_link_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_and_link) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_and_save_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_and_save) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_and_save_and_set_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_and_set_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_on_condition_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_on_condition) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_on_count_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_on_count) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_on_index_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_on_index_low_or_equal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_relative_on_condition) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_relative_and_save) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_relative_on_count) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_relative_on_index_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_relative_on_index_low_or_equal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_checksum) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_and_form_codeword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_and_swap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_double_and_swap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_and_swap_and_store) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_characters_under_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_character_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_long_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_string) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_until_substring_equal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_utf16_to_utf8) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_utf16_to_utf32) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_utf32_to_utf16) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_utf32_to_utf8) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_utf8_to_utf16) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_utf8_to_utf32) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_to_binary) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_to_decimal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_copy_access) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_exclusive_or_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_exclusive_or) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_exclusive_or_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_exclusive_or_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_execute) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_execute_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_extract_access_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_insert_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_insert_characters_under_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_insert_program_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_access_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_address_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_and_test_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_complement_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_negative_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_positive_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_monitor_call) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_move_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_move_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_move_inverse) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_move_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_move_long_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_move_numerics) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_move_string) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_move_with_offset) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_move_zones) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_single_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_single) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) z900_or_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_or) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_or_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_or_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_perform_locked_operation) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_pack) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_search_string) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_search_string_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_access_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_program_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_shift_left_double) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_shift_left_double_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_shift_left_single) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_shift_left_single_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_shift_right_double) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_shift_right_double_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_shift_right_single) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_shift_right_single_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_access_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_characters_under_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_clock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_clock_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_clock_fast) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_supervisor_call) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_and_set) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_under_mask) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_under_mask_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_under_mask_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_translate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_translate_and_test) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_translate_and_test_reverse) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_translate_and_test_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_translate_and_test_reverse_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_translate_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_unpack) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_update_tree) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) z900_add_immediate_long_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_immediate_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_logical_with_signed_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_logical_with_signed_immediate_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_and_branch_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_and_branch_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_and_branch_relative_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_and_branch_relative_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_and_trap_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_and_trap_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_halfword_immediate_halfword_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_halfword_immediate_long_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_halfword_immediate_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_halfword_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_halfword_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_halfword_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_immediate_and_branch) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_immediate_and_branch_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_immediate_and_branch_relative) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_immediate_and_branch_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_immediate_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_immediate_and_trap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_and_branch_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_and_branch_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_and_branch_relative_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_and_branch_relative_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_and_trap_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_and_trap_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_immediate_and_branch) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_immediate_and_branch_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_immediate_and_branch_relative) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_immediate_and_branch_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_immediate_and_trap_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_immediate_and_trap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_immediate_fullword_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_immediate_halfword_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_immediate_long_storage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_relative_long_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_relative_long_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_relative_long_long_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_relative_long_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_extract_cache_attribute) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_address_extended_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_and_test_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_halfword_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_halfword_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_halfword_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_halfword_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_relative_long_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_relative_long_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_relative_long_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_move_fullword_from_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_move_halfword_from_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_move_long_from_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_single_immediate_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_single_immediate_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_prefetch_data) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_prefetch_data_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_rotate_then_and_selected_bits_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_rotate_then_exclusive_or_selected_bits_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_rotate_then_insert_selected_bits_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_rotate_then_or_selected_bits_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_halfword_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_relative_long_long) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) z900_add_high_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_high_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_high_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_logical_high_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_logical_high_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_logical_with_signed_immediate_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_logical_with_signed_immediate_high_n) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_relative_on_count_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_high_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_high_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_byte_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_fullword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_halfword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_character_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_halfword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_rotate_then_insert_selected_bits_high_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_rotate_then_insert_selected_bits_low_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_character_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_fullword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_halfword_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_high_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_high_high_low_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_logical_high_high_high_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_logical_high_high_low_register) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) z900_load_and_add) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_and_add_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_and_add_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_and_add_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_and_and) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_and_and_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_and_exclusive_or) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_and_exclusive_or_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_and_or) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_and_or_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_pair_disjoint) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_pair_disjoint_long) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) z900_load_on_condition_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_on_condition_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_on_condition) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_on_condition_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_on_condition) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_on_condition_long) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) z900_add_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_distinct_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_distinct_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_logical_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_logical_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_logical_distinct_signed_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_logical_distinct_long_signed_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_and_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_and_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_exclusive_or_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_exclusive_or_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_or_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_or_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_shift_right_single_distinct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_shift_left_single_distinct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_shift_right_single_logical_distinct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_shift_left_single_logical_distinct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_distinct_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_logical_distinct_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_logical_distinct_long_register) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) z900_population_count) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) z900_load_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_long_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_fullword_high_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_long_fullword_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_long_thirtyone_and_trap) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) z900_compare_logical_and_trap) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_and_trap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_rotate_then_insert_selected_bits_long_reg_n) (BYTE inst[], REGS *regs);
>
>void (__attribute__ (( regparm(2) )) z900_branch_prediction_preload) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_prediction_relative_preload) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_next_instruction_access_intent) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) z900_clear_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_halt_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_modify_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_resume_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_address_limit) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_channel_monitor) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_reset_channel_path) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_start_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_cancel_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_channel_path_status) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_channel_report_word) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_pending_interruption) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_subchannel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_start_io) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_io) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_halt_io) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_channel) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_channel_id) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_connect_channel_set) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_disconnect_channel_set) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) z900_service_call) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) z900_channel_subsystem_call) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) z900_page_in) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_page_out) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_move_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_invalidate_expanded_storage_block_entry) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) z900_v_test_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_complement_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_count_left_zeros_in_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_count_ones_in_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_extract_vct) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_extract_vector_modes) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_restore_vr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_save_changed_vr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_save_vr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_load_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_load_vmr_complement) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_store_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_and_to_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_or_to_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_exclusive_or_to_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_save_vsr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_save_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_restore_vsr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_restore_vmr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_load_vct_from_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_clear_vr) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_set_vector_mask_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_load_vix_from_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_store_vector_parameters) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_save_vac) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_v_restore_vac) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) z900_store_fpc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_fpc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_fpc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_extract_fpc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_bfp_rounding_mode_2bit) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_bfp_rounding_mode_3bit) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_trap2) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_trap4) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_resume_program) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_trace_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_to_binary_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_to_decimal_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_logical_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_logical_carry_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_logical_borrow_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_logical_carry_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_logical_borrow_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_logical_carry_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_logical_borrow_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_logical_carry) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_logical_borrow) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_single_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_single_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_single_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_single_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_long_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_long_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_pair_to_quadword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_pair_from_quadword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_extract_stacked_registers_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_extract_psw) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_extract_and_set_extended_authority) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_address_relative_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_perform_frame_management_function) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_perform_timing_facility_function) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_perform_topology_function) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_reset_reference_bits_multiple) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_facility_list) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_facility_list_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_long_halfword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_and_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_or_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_exclusive_or_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_and_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_or_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_exclusive_or_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_logical_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_logical_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_control_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_control_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_multiple_disjoint) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_multiple_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_multiple_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_multiple_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_multiple_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_using_real_address_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_using_real_address_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_addressing_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_addressing_mode_24) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_addressing_mode_31) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_addressing_mode_64) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_program_status_word_extended) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_real_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_single_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_single_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_single_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_single_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_rotate_left_single_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_rotate_left_single_logical) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_shift_right_single_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_shift_left_single_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_shift_right_single_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_shift_left_single_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_long_thirtyone_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_under_mask_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_under_mask_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_relative_on_count_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_positive_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_negative_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_and_test_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_complement_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_real_address_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_logical_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_logical_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_logical_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_on_count_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_on_count_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_and_swap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_double_and_swap_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_on_index_high_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_on_index_low_or_equal_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_relative_on_index_high_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_relative_on_index_low_or_equal_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_characters_under_mask_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_characters_under_mask_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_insert_characters_under_mask_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_relative_on_condition_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_branch_relative_and_save_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_positive_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_negative_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_and_test_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_complement_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_long_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_long_fullword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_long_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_long_thirtyone) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_insert_immediate_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_insert_immediate_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_insert_immediate_low_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_insert_immediate_low_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_and_immediate_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_and_immediate_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_and_immediate_low_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_and_immediate_low_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_or_immediate_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_or_immediate_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_or_immediate_low_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_or_immediate_low_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_immediate_high_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_immediate_high_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_immediate_low_high) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_immediate_low_low) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_reversed_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_reversed_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_reversed_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_reversed) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_reversed_half) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_reversed_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_reversed) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_reversed_half) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_pack_ascii) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_pack_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_unpack_ascii) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_unpack_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_translate_two_to_two) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_translate_two_to_one) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_translate_one_to_two) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_translate_one_to_one) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_move_long_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_long_unicode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_logical_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_and_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_and_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_and_swap_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_double_and_swap_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_characters_under_mask_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_to_binary_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_to_decimal_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_exclusive_or_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_exclusive_or_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_insert_character_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_insert_characters_under_mask_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_access_multiple_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_address_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_byte) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_byte_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_multiple_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_real_address_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_move_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_single_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_or_immediate_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_or_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_access_multiple_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_character_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_characters_under_mask_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_store_multiple_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_halfword_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_logical_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_under_mask_y) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_and_swap_and_purge_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_invalidate_dat_table_entry) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_and_replace_dat_table_entry) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_page_table_entry_address) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_logical_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_logical_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_and_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_and_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_logical_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_exclusive_or_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_exclusive_or_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_insert_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_insert_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_or_immediate_high_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_or_immediate_low_fullword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_logical_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_logical_long_fullword_immediate) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_and_test) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_and_test_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_byte_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_long_byte_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_halfword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_long_halfword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_character) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_character_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_long_character_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_halfword) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_halfword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_logical_long_halfword_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_find_leftmost_one_long_register) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_extract_cpu_time) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_program_parameter) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) z900_ecpsvm_basic_freex) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_ecpsvm_basic_fretx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_ecpsvm_lock_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_ecpsvm_unlock_page) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_ecpsvm_decode_next_ccw) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_ecpsvm_free_ccwstor) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_ecpsvm_locate_vblock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_ecpsvm_disp1) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_ecpsvm_tpage) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_ecpsvm_tpage_lock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_ecpsvm_inval_segtab) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_ecpsvm_inval_ptable) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_ecpsvm_decode_first_ccw) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_ecpsvm_dispatch_main) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_ecpsvm_locate_rblock) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_ecpsvm_comm_ccwproc) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_ecpsvm_unxlate_ccw) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_ecpsvm_disp2) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_ecpsvm_store_level) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_ecpsvm_loc_chgshrpg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_ecpsvm_extended_freex) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_ecpsvm_extended_fretx) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_ecpsvm_prefmach_assist) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) z900_convert_bfp_long_to_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_bfp_short_to_float_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_float_long_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_float_long_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_and_signal_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_and_signal_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_and_signal_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_and_signal_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_and_signal_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_fix32_to_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_fix32_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_fix32_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_u32_to_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_u32_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_u32_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_fix64_to_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_fix64_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_fix64_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_u64_to_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_u64_to_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_u64_to_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_bfp_ext_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_bfp_long_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_bfp_short_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_bfp_ext_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_bfp_long_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_bfp_short_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_bfp_ext_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_bfp_long_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_bfp_short_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_bfp_ext_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_bfp_long_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_bfp_short_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_integer_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_integer_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_and_test_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_and_test_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_and_test_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_fp_int_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_fp_int_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_fp_int_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_lengthened_bfp_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_lengthened_bfp_short_to_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_lengthened_bfp_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_lengthened_bfp_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_lengthened_bfp_short_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_lengthened_bfp_short_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_negative_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_negative_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_negative_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_complement_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_complement_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_complement_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_positive_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_positive_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_positive_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_rounded_bfp_long_to_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_rounded_bfp_ext_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_rounded_bfp_ext_to_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_bfp_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_bfp_long_to_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_bfp_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_bfp_short_to_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_add_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_add_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_add_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_add_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_subtract_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_subtract_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_subtract_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_subtract_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_squareroot_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_squareroot_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_squareroot_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_squareroot_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_squareroot_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_bfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_bfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_bfp_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_data_class_bfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_data_class_bfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_data_class_bfp_ext) (BYTE inst[], REGS *regs);
>
>
>void (__attribute__ (( regparm(2) )) z900_copy_sign_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_complement_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_fpr_from_gr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_gr_from_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_negative_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_positive_fpr_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_dfp_rounding_mode) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_fpc_and_signal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_set_fpc_and_signal) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_add_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_and_signal_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_and_signal_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_exponent_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_compare_exponent_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_fix32_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_fix32_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_u32_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_u32_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_fix64_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_fix64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_u64_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_u64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_sbcd128_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_sbcd64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_ubcd128_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_ubcd64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_zoned_to_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_zoned_to_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_dfp_ext_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_dfp_long_to_fix32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_dfp_ext_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_dfp_long_to_u32_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_dfp_ext_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_dfp_long_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_dfp_ext_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_dfp_long_to_u64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_dfp_ext_to_sbcd128_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_dfp_long_to_sbcd64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_dfp_ext_to_ubcd128_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_dfp_long_to_ubcd64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_dfp_ext_to_zoned) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_convert_dfp_long_to_zoned) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_divide_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_extract_biased_exponent_dfp_ext_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_extract_biased_exponent_dfp_long_to_fix64_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_extract_significance_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_extract_significance_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_insert_biased_exponent_fix64_to_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_insert_biased_exponent_fix64_to_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_and_test_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_and_test_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_fp_int_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_fp_int_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_lengthened_dfp_long_to_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_lengthened_dfp_short_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_rounded_dfp_ext_to_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_load_rounded_dfp_long_to_short_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_multiply_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_quantize_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_quantize_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_reround_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_reround_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_shift_coefficient_left_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_shift_coefficient_left_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_shift_coefficient_right_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_shift_coefficient_right_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_dfp_ext_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_subtract_dfp_long_reg) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_data_class_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_data_class_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_data_class_dfp_short) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_data_group_dfp_ext) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_data_group_dfp_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_test_data_group_dfp_short) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) z900_perform_floating_point_operation) (BYTE inst[], REGS *regs);
>
>
>
>void (__attribute__ (( regparm(2) )) z900_perform_processor_assist) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_extract_transaction_nesting_depth) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_nontransactional_store_long) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_transaction_abort) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_transaction_begin) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_transaction_begin_constrained) (BYTE inst[], REGS *regs);
>void (__attribute__ (( regparm(2) )) z900_transaction_end) (BYTE inst[], REGS *regs);
># 42 "cpu.c" 2
># 1 "inline.h" 1
># 16 "inline.h"
>static inline U16 z900_translate_asn (U16 asn, REGS *regs,
>        U32 *asteo, U32 aste[]);
>static inline int z900_authorize_asn (U16 ax, U32 aste[],
>        int atemask, REGS *regs);
>
>
>static inline U16 z900_translate_alet (U32 alet, U16 eax,
>        int acctype, REGS *regs, U32 *asteo, U32 aste[]);
>static inline void z900_purge_alb_all ();
>static inline void z900_purge_alb (REGS *regs);
>
>static inline int z900_translate_addr (U64 vaddr, int arn,
>        REGS *regs, int acctype);
>static inline void z900_purge_tlb_all ();
>static inline void z900_purge_tlb (REGS *regs);
>static inline void z900_purge_tlbe_all (U64 pfra);
>static inline void z900_purge_tlbe (REGS *regs, U64 pfra);
>static inline void z900_invalidate_tlb (REGS *regs, BYTE mask);
>
>
>
>static inline void z900_invalidate_tlbe (REGS *regs, BYTE *main);
>static inline void z900_invalidate_pte (BYTE ibyte, U64 op1,
>        U32 op2, REGS *regs);
>static inline BYTE *z900_logical_to_main (U64 addr, int arn,
>        REGS *regs, int acctype, BYTE akey);
># 51 "inline.h"
>static inline BYTE *z900_logical_to_main (U64 addr, int arn, REGS *regs,
>        int acctype, BYTE akey);
>static inline int z900_translate_addr (U64 vaddr, int arn, REGS *regs,
>        int acctype);
>
>
>static inline void z900_vstorec (void *src, BYTE len,
>        U64 addr, int arn, REGS *regs);
>static inline void z900_vstoreb (BYTE value, U64 addr,
>        int arn, REGS *regs);
>static inline void z900_vstore2 (U16 value, U64 addr, int arn,
>        REGS *regs);
>static inline void z900_vstore4 (U32 value, U64 addr, int arn,
>        REGS *regs);
>static inline void z900_vstore8 (U64 value, U64 addr, int arn,
>        REGS *regs);
>static inline void z900_vfetchc (void *dest, BYTE len,
>        U64 addr, int arn, REGS *regs);
>static inline BYTE z900_vfetchb (U64 addr, int arn,
>        REGS *regs);
>static inline U16 z900_vfetch2 (U64 addr, int arn,
>        REGS *regs);
>static inline U32 z900_vfetch4 (U64 addr, int arn,
>        REGS *regs);
>static inline U64 z900_vfetch8 (U64 addr, int arn,
>        REGS *regs);
>static inline void z900_move_chars (U64 addr1, int arn1,
>      BYTE key1, U64 addr2, int arn2, BYTE key2, int len, REGS *regs);
>static inline void z900_validate_operand (U64 addr, int arn,
>        int len, int acctype, REGS *regs);
>static inline BYTE * z900_instfetch (REGS *regs, int exec);
>
>
>static inline BYTE * s370_instfetch (REGS *regs, int exec);
>
>
>
>static inline BYTE * s390_instfetch (REGS *regs, int exec);
># 323 "inline.h"
>static inline int z900_is_fetch_protected (U64 addr, BYTE skey,
>                    BYTE akey, REGS *regs)
>{
>    ((addr)=(addr));
>    ((regs)=(regs));
>
>
>
>
>
>    if (__builtin_expect((akey == 0 || akey == (skey & 0xF0) || !(skey & 0x08)),1)
>
>                               )
>    return 0;
>
>
>
>
>    if (addr < 2048
>    && (regs->cr[(0)].D & 0x02000000)
>    && regs->dat.private == 0)
>    return 0;
>
>
>
>
>
>
>    if ((skey & 0xF0) == 0x90
>    && (regs->cr[(0)].D & 0x01000000))
>    return 0;
>
>
>
>    return 1;
>
>}
># 371 "inline.h"
>static inline int z900_is_low_address_protected (U64 addr,
>                                              REGS *regs)
>{
>
>
>
>    if (addr & 0xFFFFFFFFFFFFEE00ULL)
>
>
>
>
>
>        return 0;
>
>
>
>    if ((regs->cr[(0)].D & 0x10000000) == 0)
>        return 0;
>
>
>
>
>    if (regs->sie_active)
>        return 0;
>
>
>
>
>    if (regs->dat.private)
>        return 0;
>
>
>    return 1;
>
>}
># 421 "inline.h"
>static inline int z900_is_store_protected (U64 addr, BYTE skey,
>               BYTE akey, REGS *regs)
>{
>
>
>
>
>    if (z900_is_low_address_protected (addr, regs))
>        return 1;
>
>
>
>
>    if (regs->dat.protect)
>        return 1;
>
>    if(__builtin_expect(((regs)->sie_mode),0) && regs->hostregs->dat.protect)
>        return 1;
>
>
>
>
>    if (akey == 0)
>        return 0;
>
>
>
>
>
>    if ((skey & 0xF0) == 0x90
>        && (regs->cr[(0)].D & 0x01000000))
>        return 0;
>
>
>
>
>    if (akey != (skey & 0xF0))
>        return 1;
>
>
>    return 0;
>
>}
># 475 "inline.h"
>static inline BYTE *z900_fetch_main_absolute (U64 addr,
>                                REGS *regs)
>
>{
>
>
>
>
>
>    do { if(__builtin_expect((((regs))->sie_mode),0) && !(regs)->sie_pref) *(&addr) = ( z900_logical_to_main(((regs)->sie_mso + *(&addr)), (18), ((regs)->hostregs), ((0x0004)), (0)), ((regs)->hostregs)->dat.aaddr ); } while(0);
>
>
>    (regs)->storkeys[(addr)>>11] |= 0x04;
>
>
>    return (regs->mainstor + addr);
>
>}
># 503 "inline.h"
>static inline U64 z900_fetch_doubleword_absolute (U64 addr,
>                                REGS *regs)
>{
>
>
>
>
>
>
>    return __bswap_64 (*(U64 *)z900_fetch_main_absolute((addr), (regs)));
>
>
>
>}
># 527 "inline.h"
>static inline U32 z900_fetch_fullword_absolute (U64 addr,
>                                REGS *regs)
>{
>    return __bswap_32 (fetch_fw_noswap((z900_fetch_main_absolute((addr), (regs)))));
>}
># 542 "inline.h"
>static inline U16 z900_fetch_halfword_absolute (U64 addr,
>                                REGS *regs)
>{
>    return (__extension__ ({ unsigned short int __v, __x = (unsigned short int) (fetch_hw_noswap((z900_fetch_main_absolute((addr), (regs))))); if (__builtin_constant_p (__x)) __v = ((unsigned short int) ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8))); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; }));
>}
># 555 "inline.h"
>static inline void z900_store_doubleword_absolute (U64 value,
>                          U64 addr, REGS *regs)
>{
>
>
>
>
>
>    do { if(__builtin_expect((((regs))->sie_mode),0) && !(regs)->sie_pref) *(&addr) = ( z900_logical_to_main(((regs)->sie_mso + *(&addr)), (18), ((regs)->hostregs), ((0x0002)), (0)), ((regs)->hostregs)->dat.aaddr ); } while(0);
>
>
>    (regs)->storkeys[(addr)>>11] |= (0x04 | 0x02);
>
>
>    store_dw_i686_noswap((regs->mainstor + addr),__bswap_64 ((value)));
>
>}
># 580 "inline.h"
>static inline void z900_store_fullword_absolute (U32 value,
>                          U64 addr, REGS *regs)
>{
>
>
>
>
>
>    do { if(__builtin_expect((((regs))->sie_mode),0) && !(regs)->sie_pref) *(&addr) = ( z900_logical_to_main(((regs)->sie_mso + *(&addr)), (18), ((regs)->hostregs), ((0x0002)), (0)), ((regs)->hostregs)->dat.aaddr ); } while(0);
>
>
>    (regs)->storkeys[(addr)>>11] |= (0x04 | 0x02);
>
>
>    store_fw_noswap((regs->mainstor + addr), __bswap_32 ((value)));
>
>}
># 637 "inline.h"
>static inline U64 z900_subspace_replace (U64 std, U32 asteo,
>                        U16 *xcode, REGS *regs)
>{
>U32 ducto;
>U32 duct0;
>U32 duct1;
>U32 duct3;
>U32 ssasteo;
>U32 ssaste[16];
>BYTE *p;
>
>
>    if (xcode != ((void *)0)) *xcode = 0;
>
>
>
>
>    if (!1
>        || (std & 0x200) == 0)
>        return std;
>
>
>    ducto = regs->cr[(2)].D & 0x7FFFFFC0;
>    ducto = ( (U64)((ducto) & 0xFFFFFFFFFFFFE000ULL) == (U64)0 || (U64)((ducto) & 0xFFFFFFFFFFFFE000ULL) == (regs->px.F.L.F) ? (ducto) ^ (regs->px.F.L.F) : (ducto) );
>
>
>    if (ducto > regs->mainlim)
>        regs->program_interrupt (regs, 0x0005);
>
>
>
>    p = z900_fetch_main_absolute((ducto), (regs));
>    duct0 = __bswap_32 (fetch_fw_noswap((p)));
>    duct1 = __bswap_32 (fetch_fw_noswap((p+4)));
>    duct3 = __bswap_32 (fetch_fw_noswap((p+12)));
>
>
>
>
>    if ((duct1 & 0x80000000) == 0
>        || asteo != (duct0 & 0x7FFFFFC0))
>        return std;
>
>
>    ssasteo = duct1 & 0x7FFFFFC0;
>    ssasteo = ( (U64)((ssasteo) & 0xFFFFFFFFFFFFE000ULL) == (U64)0 || (U64)((ssasteo) & 0xFFFFFFFFFFFFE000ULL) == (regs->px.F.L.F) ? (ssasteo) ^ (regs->px.F.L.F) : (ssasteo) );
>
>
>    if (ssasteo > regs->mainlim)
>        regs->program_interrupt (regs, 0x0005);
>
>
>
>    p = z900_fetch_main_absolute((ssasteo), (regs));
>    ssaste[0] = __bswap_32 (fetch_fw_noswap((p)));
>    ssaste[2] = __bswap_32 (fetch_fw_noswap((p+8)));
>
>    ssaste[3] = __bswap_32 (fetch_fw_noswap((p+12)));
>
>    ssaste[5] = __bswap_32 (fetch_fw_noswap((p+20)));
>
>
>    if (ssaste[0] & 0x80000000)
>    {
>        regs->excarid = 0;
>        if (xcode == ((void *)0))
>            regs->program_interrupt (regs, 0x002B);
>        else
>            *xcode = 0x002B;
>        return 0;
>    }
>
>
>
>    if ((ssaste[5] & 0xFFFFFFFF) != (duct3 & 0xFFFFFFFF))
>    {
>        regs->excarid = 0;
>        if (xcode == ((void *)0))
>            regs->program_interrupt (regs, 0x002C);
>        else
>            *xcode = 0x002C;
>        return 0;
>    }
>
>
>
>
>    std &= (0x040 | 0x080);
>    std |= ((((U64)((ssaste)[2])<<32)|(U64)((ssaste)[3]))
>                & ~((U64)(0x040 | 0x080)));
>
>
>    return std;
>
>}
>
>
># 1 "dat.h" 1
># 53 "dat.h"
>static inline U16 z900_translate_asn (U16 asn, REGS *regs,
>                                                U32 *asteo, U32 aste[])
>{
>U32 afte_addr;
>U32 afte;
>U32 aste_addr;
>BYTE *aste_main;
>int code;
>int numwords;
>int i;
>
>
>    afte_addr = (regs->cr[(14)].D & 0x0007FFFF) << 12;
>    afte_addr += (asn & 0xFFC0) >> 4;
>
>
>    if (afte_addr > regs->mainlim)
>        goto asn_addr_excp;
>
>
>
>    afte_addr = ( (U64)((afte_addr) & 0xFFFFFFFFFFFFE000ULL) == (U64)0 || (U64)((afte_addr) & 0xFFFFFFFFFFFFE000ULL) == (regs->px.F.L.F) ? (afte_addr) ^ (regs->px.F.L.F) : (afte_addr) );
>    afte = z900_fetch_fullword_absolute (afte_addr, regs);
>
>
>    if (afte & 0x80000000)
>        goto asn_afx_tran_excp;
># 93 "dat.h"
>    if (!1) {
>        aste_addr = afte & 0x7FFFFFF0;
>        aste_addr += (asn & 0x003F) << 4;
>        numwords = 4;
>    } else {
>        aste_addr = afte & 0x7FFFFFC0;
>        aste_addr += (asn & 0x003F) << 6;
>        numwords = 16;
>    }
>
>
>    aste_addr &= 0x7FFFFFFF;
>
>
>    if (aste_addr > regs->mainlim)
>        goto asn_addr_excp;
>
>
>    *asteo = aste_addr;
>
>
>
>
>    aste_addr = ( (U64)((aste_addr) & 0xFFFFFFFFFFFFE000ULL) == (U64)0 || (U64)((aste_addr) & 0xFFFFFFFFFFFFE000ULL) == (regs->px.F.L.F) ? (aste_addr) ^ (regs->px.F.L.F) : (aste_addr) );
>    aste_main = z900_fetch_main_absolute((aste_addr), (regs));
>    for (i = 0; i < numwords; i++)
>    {
>        aste[i] = __bswap_32 (fetch_fw_noswap((aste_main)));
>        aste_main += 4;
>    }
>
>    while (i < 16) aste[i++] = 0;
>
>
>
>    if (aste[0] & 0x80000000)
>        goto asn_asx_tran_excp;
># 142 "dat.h"
>    return 0;
>
>
>asn_addr_excp:
>    code = 0x0005;
>    goto asn_prog_check;
>
>
>
>
>
>
>
>asn_prog_check:
>    regs->program_interrupt (regs, code);
>
>
>asn_afx_tran_excp:
>    regs->ea.D = asn;
>    code = 0x0020;
>    return code;
>
>asn_asx_tran_excp:
>    regs->ea.D = asn;
>    code = 0x0021;
>    return code;
>
>}
># 203 "dat.h"
>static inline int z900_authorize_asn (U16 ax, U32 aste[],
>                                               int atemask, REGS *regs)
>{
>U32 ato;
>int atl;
>BYTE ate;
>
>
>
>
>    ato = aste[0] & 0x7FFFFFFC;
>    atl = aste[1] & 0x0000FFF0;
>
>
>    if ((ax & 0xFFF0) > atl)
>        return 1;
>
>
>
>    ato += (ax >> 2);
>
>
>    ato &= 0x7FFFFFFF;
>
>
>    if (ato > regs->mainlim)
>        goto auth_addr_excp;
>
>
>
>    ato = ( (U64)((ato) & 0xFFFFFFFFFFFFE000ULL) == (U64)0 || (U64)((ato) & 0xFFFFFFFFFFFFE000ULL) == (regs->px.F.L.F) ? (ato) ^ (regs->px.F.L.F) : (ato) );
>
>    do { if(__builtin_expect((((regs))->sie_mode),0) && !(regs)->sie_pref) *(&ato) = ( z900_logical_to_main(((regs)->sie_mso + *(&ato)), (18), ((regs)->hostregs), ((0)), (0)), ((regs)->hostregs)->dat.aaddr ); } while(0);
>
>    ate = regs->mainstor[ato];
>    ate <<= ((ax & 0x03)*2);
>
>
>    (regs)->storkeys[(ato)>>11] |= 0x04;
>
>
>
>    if ((ate & atemask) == 0)
>        return 1;
>
>
>    return 0;
>
>
>auth_addr_excp:
>    regs->program_interrupt (regs, 0x0005);
>    return 1;
>
>}
># 299 "dat.h"
>static inline U16 z900_translate_alet (U32 alet, U16 eax,
>            int acctype, REGS *regs, U32 *asteo, U32 aste[])
>{
>U32 cb;
>U32 ald;
>U32 alo;
>U32 all;
>U32 ale[4];
>U32 aste_addr;
>U32 abs;
>BYTE *mn;
>int i;
>
>    regs->dat.protect = 0;
>
>
>    if ( alet & 0xFE000000 )
>        goto alet_spec_excp;
>
>
>
>
>
>
>    cb = (alet & 0x01000000) ?
>            regs->cr[(5)].D & 0x7FFFFFC0 :
>            regs->cr[(2)].D & 0x7FFFFFC0;
>
>
>    if (cb > regs->mainlim)
>        goto alet_addr_excp;
>
>
>
>
>
>    cb = ( (U64)((cb) & 0xFFFFFFFFFFFFE000ULL) == (U64)0 || (U64)((cb) & 0xFFFFFFFFFFFFE000ULL) == (regs->px.F.L.F) ? (cb) ^ (regs->px.F.L.F) : (cb) );
>    ald = z900_fetch_fullword_absolute (cb+16, regs);
>
>
>
>
>    alo = ald & 0x7FFFFF80;
>    all = ald & 0x0000007F;
>
>
>    if (((alet & 0x0000FFFF) >> 3) > all)
>        goto alen_tran_excp;
>
>
>    alo += (alet & 0x0000FFFF) << 4;
>
>
>    if (alo > regs->mainlim)
>        goto alet_addr_excp;
>
>
>
>
>    alo = ( (U64)((alo) & 0xFFFFFFFFFFFFE000ULL) == (U64)0 || (U64)((alo) & 0xFFFFFFFFFFFFE000ULL) == (regs->px.F.L.F) ? (alo) ^ (regs->px.F.L.F) : (alo) );
>    mn = z900_fetch_main_absolute((alo), (regs));
>    for (i = 0; i < 4; i++)
>    {
>        ale[i] = __bswap_32 (fetch_fw_noswap((mn)));
>        mn += 4;
>    }
>
>
>    if (ale[0] & 0x80000000)
>        goto alen_tran_excp;
>
>
>
>    if (!(acctype & 0x0800)
>        && (ale[0] & 0x00FF0000) != (alet & 0x00FF0000))
>        goto ale_seq_excp;
>
>
>    aste_addr = ale[2] & 0x7FFFFFC0;
>
>
>    abs = ( (U64)((aste_addr) & 0xFFFFFFFFFFFFE000ULL) == (U64)0 || (U64)((aste_addr) & 0xFFFFFFFFFFFFE000ULL) == (regs->px.F.L.F) ? (aste_addr) ^ (regs->px.F.L.F) : (aste_addr) );
>    if (abs > regs->mainlim)
>        goto alet_addr_excp;
>    mn = z900_fetch_main_absolute((abs), (regs));
>
>
>
>
>    for (i = 0; i < 16; i++)
>    {
>        aste[i] = __bswap_32 (fetch_fw_noswap((mn)));
>        mn += 4;
>    }
>
>
>    if (aste[0] & 0x80000000)
>        goto aste_vald_excp;
>
>
>    if ((aste[5] & 0xFFFFFFFF) != (ale[3] & 0xFFFFFFFF))
>        goto aste_seq_excp;
>
>
>
>    if (!(acctype & 0x0800))
>    {
>
>
>
>        if ((ale[0] & 0x01000000)
>                && (ale[0] & 0x0000FFFF) != eax)
>        {
># 424 "dat.h"
>            if (z900_authorize_asn(eax, aste, 0x40, regs) != 0)
>                goto ext_auth_excp;
>        }
>
>    }
>
>
>    if (ale[0] & 0x02000000)
>        regs->dat.protect = 2;
>
>
>    *asteo = aste_addr;
>    return 0;
>
>
>
>alet_addr_excp:
>    regs->dat.xcode = 0x0005;
>    goto alet_prog_check;
>
>
>
>
>
>
>
>alet_prog_check:
>    regs->program_interrupt (regs, regs->dat.xcode);
>
>
>alet_spec_excp:
>    regs->dat.xcode = 0x0028;
>    return regs->dat.xcode;
>
>alen_tran_excp:
>    regs->dat.xcode = 0x0029;
>    return regs->dat.xcode;
>
>ale_seq_excp:
>    regs->dat.xcode = 0x002A;
>    return regs->dat.xcode;
>
>aste_vald_excp:
>    regs->dat.xcode = 0x002B;
>    return regs->dat.xcode;
>
>aste_seq_excp:
>    regs->dat.xcode = 0x002C;
>    return regs->dat.xcode;
>
>ext_auth_excp:
>    regs->dat.xcode = 0x002D;
>    return regs->dat.xcode;
>
>}
>
>
>
>
>
>
>
>static inline void z900_purge_alb (REGS *regs)
>{
>int i;
>
>    for(i = 1; i < 16; i++)
>        if(regs->aea_ar[i] >= 16 && regs->aea_ar[i] != 32)
>            regs->aea_ar[i] = 0;
>
>    if(regs->host && regs->guestregs)
>        for(i = 1; i < 16; i++)
>            if(regs->guestregs->aea_ar[i] >= 16 && regs->guestregs->aea_ar[i] != 32)
>                regs->guestregs->aea_ar[i] = 0;
>
>}
>
>
>
>
>static inline void z900_purge_alb_all ()
>{
>int i;
>
>    for (i = 0; i < sysblk.maxcpu; i++)
>        if ((sysblk.regs[(i)] != ((void *)0))
>         && (sysblk.regs[i]->cpubit & sysblk.started_mask))
>            z900_purge_alb (sysblk.regs[i]);
>
>}
># 561 "dat.h"
>static inline U16 z900_load_address_space_designator (int arn,
>           REGS *regs, int acctype)
>{
>
>U32 alet;
>U32 asteo;
>U32 aste[16];
>U16 eax;
>
>
>
>
>    switch(arn) {
>
>    case 18:
>        regs->dat.stid = 0x000;
>        regs->dat.asd = regs->cr[(1)].D;
>        break;
>
>    case 17:
>        regs->dat.stid = 0x002;
>        regs->dat.asd = regs->cr[(7)].D;
>        break;
>
>    case 16:
>        regs->dat.stid = 0x003;
>        regs->dat.asd = regs->cr[(13)].D;
>        break;
>
>    case 19:
>        regs->dat.stid = 0;
>        regs->dat.asd = 0xFFFFFFFFFFFFFFFFULL;
>        break;
>
>    case 20:
>        switch(regs->aea_ar[20]) {
>
>        case 1:
>            regs->dat.stid = 0x000;
>            break;
>
>        case 13:
>            regs->dat.stid = 0x003;
>            break;
>
>        default:
>            regs->dat.stid = 0;
>        }
>
>        regs->dat.asd = regs->cr[(regs->aea_ar[20])].D;
>        break;
>
>    default:
>
>
>        if (((&regs->psw)->asc == 0x40)
>         || (((regs)->sie_active) && ( ((((regs->guestregs))->siebk->mx) & (0x01)) && (((&(regs->guestregs)->psw)->asc & ( 1 << (6) )) != 0) ))
>         || (arn & 16)
>           )
>        {
>
>            arn &= 0xF;
>
>
>            alet = (arn == 0) ? 0 :
>
>                   (((regs)->sie_active) && ( ((((regs->guestregs))->siebk->mx) & (0x01)) && (((&(regs->guestregs)->psw)->asc & ( 1 << (6) )) != 0) ))
>                   ? regs->guestregs->ar[(arn)] :
>
>                   ((regs)->sie_active) ? 0 :
>
>                   regs->ar[(arn)];
>
>
>            switch (alet) {
>
>            case 0:
>
>                regs->dat.stid = 0x000;
>                regs->dat.asd = regs->cr[(1)].D;
>                break;
>
>            case 1:
>
>                regs->dat.stid = 0x002;
>                regs->dat.asd = regs->cr[(7)].D;
>                break;
>
>            default:
>
>                if(regs->aea_ar[arn] >= 16 && regs->aea_ar[arn] != 32)
>                {
>                    regs->dat.asd = regs->cr[(regs->aea_ar[arn])].D;
>                    regs->dat.protect = regs->aea_aleprot[arn];
>                    regs->dat.stid = 0x001;
>                }
>                else
>                {
>
>                    eax = regs->cr[(8)].F.L.H.H.H;
>
>
>                    if (z900_translate_alet (alet, eax, acctype,
>                                                  regs, &asteo, aste))
>
>                        return regs->dat.xcode;
>
>
>                    regs->dat.asd = (((U64)((aste)[2])<<32)|(U64)((aste)[3]));
>                    regs->dat.stid = 0x001;
>                    if(regs->dat.protect & 2)
>                    {
>
>                       regs->dat.asd ^= 0xC10;
>                       regs->dat.asd |= 0x100;
>
>
>
>
>                    }
>
>
>                    regs->cr[(16 + arn)].D = regs->dat.asd;
>                    regs->aea_ar[arn] = 16 + arn;
>                    regs->aea_common[16 + arn] = (regs->dat.asd & (0x100|0x020)) == 0;
>                    regs->aea_aleprot[arn] = regs->dat.protect & 2;
>
>                }
>
>            }
>
>            break;
>
>        }
>
>
>
>        if (((&regs->psw)->asc == 0x80))
>        {
>            regs->dat.stid = 0x002;
>            regs->dat.asd = regs->cr[(7)].D;
>            break;
>        }
>
>
>
>        if (((&regs->psw)->asc == 0xC0))
>        {
>            regs->dat.stid = 0x003;
>            regs->dat.asd = regs->cr[(13)].D;
>            break;
>        }
>
>
>
>        regs->dat.stid = 0x000;
>        regs->dat.asd = regs->cr[(1)].D;
>        break;
>
>    }
>
>    return 0;
>
>}
># 816 "dat.h"
>static inline int z900_translate_addr (U64 vaddr, int arn,
>                                            REGS *regs, int acctype)
>{
>U64 sto = 0;
>U64 pto = 0;
>int cc;
>int tlbix = (((U32)(vaddr) >> 12) & 0x3FF);
># 1111 "dat.h"
>U64 rte;
>
>U64 ste = 0;
>U64 pte = 0;
>BYTE tt;
>BYTE tl;
>BYTE tf;
>U16 rfx, rsx, rtx;
>
>U16 sx, px;
>
>
>    regs->dat.private = regs->dat.protect = 0;
>
>
>    if (z900_load_address_space_designator (arn, regs, acctype))
>        goto tran_alet_excp;
>
>
>    regs->dat.private = ((regs->dat.asd & (0x100|0x020)) != 0);
>
>
>
>
>    if ( ((vaddr & 0xFFFFFFFFFFC00000ULL) | regs->tlbID) == regs->tlb.vaddr[(tlbix)].D
>        && (regs->tlb.common[tlbix] || regs->dat.asd == regs->tlb.asd[(tlbix)].D)
>        && !(regs->tlb.common[tlbix] && regs->dat.private)
>        && !(acctype & 0x0100) )
>    {
>        pte = regs->tlb.pte[(tlbix)].D;
>        if (regs->tlb.protect[tlbix])
>            regs->dat.protect = regs->tlb.protect[tlbix];
>    }
>    else
>    {
>
>        if (regs->dat.asd & 0x020)
>        {
>
>
>
>            if(acctype & 0x0200)
>                goto tran_spec_excp;
>
>
>            if(acctype & 0x0400)
>                goto spec_oper_excp;
>
>
>            pte = vaddr & 0xFFFFFFFFFFFFF000ULL;
>        }
>        else
>        {
>
>
>            sto = regs->dat.asd & 0xFFFFFFFFFFFFF000ULL;
>            tf = 0;
>            tt = regs->dat.asd & 0x00C;
>            tl = regs->dat.asd & 0x003;
>
>
>
>
>
>            rfx = (vaddr >> 50) & 0x3FF8;
>            rsx = (vaddr >> 39) & 0x3FF8;
>            rtx = (vaddr >> 28) & 0x3FF8;
>
>
>
>
>            sx = (vaddr >> 17) & 0x3FF8;
>
>
>
>
>            px = (vaddr >> 9) & 0x07F8;
>
>
>
>            if ((rfx != 0 && tt < 0xC)
>                || (rsx != 0 && tt < 0x8)
>                || (rtx != 0 && tt < 0x4))
>                goto asce_type_excp;
>
>
>            switch (tt) {
>
>
>            case 0xC:
>
>
>
>                if (tl < (rfx >> 12))
>                    goto reg_first_excp;
>
>
>
>
>                sto += rfx;
>
>
>                if (sto > regs->mainlim)
>                    goto address_excp;
>
>
>
>
>                rte = z900_fetch_doubleword_absolute (sto, regs);
>
>
>
>
>                if (rte & 0x020)
>                    goto reg_first_invalid;
>
>
>
>
>                if ((rte & 0x00C) != 0xC)
>                    goto tran_spec_excp;
>
>
>                if ((regs->cr[(0)].F.L.F & 0x00800000)
>                 && (rte & 0x200))
>                    regs->dat.protect |= 1;
>
>
>
>
>                sto = rte & 0xFFFFFFFFFFFFF000ULL;
>                tf = (rte & 0x0C0) >> 6;
>                tl = rte & 0x003;
>
>
>
>
>            case 0x8:
>
>
>
>                if (tf > (rsx >> 12))
>                    goto reg_second_excp;
>
>
>
>                if (tl < (rsx >> 12))
>                    goto reg_second_excp;
>
>
>
>
>                sto += rsx;
>
>
>                if (sto > regs->mainlim)
>                    goto address_excp;
>
>
>
>
>                rte = z900_fetch_doubleword_absolute (sto, regs);
>
>
>
>
>                if (rte & 0x020)
>                    goto reg_second_invalid;
>
>
>
>
>                if ((rte & 0x00C) != 0x8)
>                    goto tran_spec_excp;
>
>
>                if ((regs->cr[(0)].F.L.F & 0x00800000)
>                 && (rte & 0x200))
>                    regs->dat.protect |= 1;
>
>
>
>
>                sto = rte & 0xFFFFFFFFFFFFF000ULL;
>                tf = (rte & 0x0C0) >> 6;
>                tl = rte & 0x003;
>
>
>
>
>            case 0x4:
>
>
>
>                if (tf > (rtx >> 12))
>                    goto reg_third_excp;
>
>
>
>                if (tl < (rtx >> 12))
>                    goto reg_third_excp;
>
>
>
>
>                sto += rtx;
>
>
>                if (sto > regs->mainlim)
>                    goto address_excp;
>
>
>
>
>                rte = z900_fetch_doubleword_absolute (sto, regs);
>
>
>
>
>                if (rte & 0x020)
>                    goto reg_third_invalid;
>
>
>
>
>                if ((rte & 0x00C) != 0x4)
>                    goto tran_spec_excp;
># 1351 "dat.h"
>                if ((regs->cr[(0)].F.L.F & 0x00800000)
>                 && (rte & 0x200))
>                    regs->dat.protect |= 1;
># 1399 "dat.h"
>                sto = rte & 0xFFFFFFFFFFFFF000ULL;
>                tf = (rte & 0x0C0) >> 6;
>                tl = rte & 0x003;
>
>
>            }
>
>
>
>
>
>
>            sto += sx;
>
>
>
>            if (tf > (sx >> 12))
>                goto seg_tran_length;
>
>
>
>            if (tl < (sx >> 12))
>                goto seg_tran_length;
>
>
>            if (sto > regs->mainlim)
>                goto address_excp;
>
>
>
>            ste = z900_fetch_doubleword_absolute (sto, regs);
>
>
>
>            if (ste & 0x020)
>                goto seg_tran_invalid;
>
>
>
>            if ((ste & 0x00C) != 0x0)
>                goto tran_spec_excp;
>
>
>
>
>            if (regs->dat.private && (ste & 0x010))
>                goto tran_spec_excp;
>
>
>            if ((regs->cr[(0)].F.L.F & 0x00800000)
>              && (ste & 0x400))
>            {
>
>
>                if (ste & 0x200)
>                    regs->dat.protect |= 1;
>
>
>                if (__builtin_expect((acctype & 0x0400),0))
>                {
>                    regs->dat.raddr = sto | (regs->dat.protect ? 0x04 : 0);
>
>                    regs->dat.xcode = 0;
>                    cc = 2;
>                    return cc;
>                }
>
>
>
>                regs->dat.raddr = (ste & 0xFFFFFFFFFFF00000ULL) | (vaddr & ~0xFFFFFFFFFFF00000ULL);
>
>                regs->dat.rpfra = ((ste & 0xFFFFFFFFFFF00000ULL) | (vaddr & ~0xFFFFFFFFFFF00000ULL)) & 0xFFFFFFFFFFFFF000ULL;
>
>
>
>
>                if (!(acctype & 0x0100))
>                {
>                    regs->tlb.asd[(tlbix)].D = regs->dat.asd;
>                    regs->tlb.vaddr[(tlbix)].D = (vaddr & 0xFFFFFFFFFFC00000ULL) | regs->tlbID;
>
>                    regs->tlb.pte[(tlbix)].D = ((ste & 0xFFFFFFFFFFF00000ULL) | (vaddr & ~0xFFFFFFFFFFF00000ULL)) & 0xFFFFFFFFFFFFF000ULL;
>                    regs->tlb.common[tlbix] = (ste & 0x00000010) ? 1 : 0;
>                    regs->tlb.protect[tlbix] = regs->dat.protect;
>                    regs->tlb.acc[tlbix] = 0;
>                    regs->tlb.main[tlbix] = ((void *)0);
>                }
>
>
>                regs->dat.xcode = 0;
>                return 0;
>
>            }
>
>
>
>            pto = ste & 0xFFFFFFFFFFFFF800ULL;
>
>
>
>
>
>            pto += px;
>
>
>            if (acctype & 0x0400)
>            {
>                regs->dat.raddr = pto;
>                regs->dat.xcode = 0;
>                cc = (ste & 0x200) ? 1 : 0;
>
>                if ((regs->cr[(0)].F.L.F & 0x00800000)
>                  && regs->dat.protect)
>                    cc = 1;
>
>                return cc;
>            }
>
>
>            if (pto > regs->mainlim)
>                goto address_excp;
>
>
>
>            pte = z900_fetch_doubleword_absolute (pto, regs);
>
>
>
>            if (pte & 0x400)
>                goto page_tran_invalid;
>
>
>            if (pte & 0x800)
>                goto tran_spec_excp;
>
>        }
>
>
>
>        if ((ste & 0x200) || (pte & 0x200))
>            regs->dat.protect |= 1;
>
>
>        if (!(acctype & 0x0100))
>        {
>            regs->tlb.asd[(tlbix)].D = regs->dat.asd;
>            regs->tlb.vaddr[(tlbix)].D = (vaddr & 0xFFFFFFFFFFC00000ULL) | regs->tlbID;
>            regs->tlb.pte[(tlbix)].D = pte;
>            regs->tlb.common[tlbix] = (ste & 0x00000010) ? 1 : 0;
>            regs->tlb.protect[tlbix] = regs->dat.protect;
>            regs->tlb.acc[tlbix] = 0;
>            regs->tlb.main[tlbix] = ((void *)0);
>        }
>    }
>
>    if(!(acctype & 0x0200))
>    {
>
>
>        regs->dat.raddr = (pte & 0xFFFFFFFFFFFFF000ULL) | (vaddr & 0xFFF);
>        regs->dat.rpfra = (pte & 0xFFFFFFFFFFFFF000ULL);
>    }
>    else
>        regs->dat.raddr = pto;
>
>
>
>
>
>    regs->dat.xcode = 0;
>    return 0;
>
>
>
>address_excp:
>
>
>    regs->dat.xcode = 0x0005;
>    goto tran_prog_check;
>
>tran_spec_excp:
># 1589 "dat.h"
>    regs->dat.xcode = 0x0012;
>    goto tran_prog_check;
>
>
>spec_oper_excp:
>    regs->dat.xcode = 0x0013;
>    goto tran_prog_check;
>
>
>tran_prog_check:
>
>
>    if(acctype & 0x1000)
>    {
>        cc = 5;
>        return cc;
>    }
>
>    regs->program_interrupt (regs, regs->dat.xcode);
>
>
>seg_tran_invalid:
>
>    if (acctype & 0x0400)
>    {
>        regs->dat.raddr = sto;
>        cc = 2;
>        return cc;
>    }
>
>
>    regs->dat.xcode = 0x0010;
>    regs->dat.raddr = sto;
>    cc = 1;
>    goto tran_excp_addr;
>
>page_tran_invalid:
>    regs->dat.xcode = 0x0011;
>    regs->dat.raddr = pto;
>    if(acctype & 0x0200) return 0;
>    cc = 2;
>    goto tran_excp_addr;
># 1640 "dat.h"
>seg_tran_length:
>
>
>    regs->dat.xcode = 0x0010;
>    regs->dat.raddr = sto;
>    cc = 3;
>    goto tran_excp_addr;
>
>tran_alet_excp:
>    regs->excarid = arn;
>    cc = (acctype & 0x0400) ? 3 : 4;
>    return cc;
>
>
>reg_first_invalid:
>
>    if (acctype & 0x0400)
>    {
>        regs->dat.raddr = sto | (0xC >> 2);
>        cc = 2;
>        return cc;
>    }
>
>
>    goto reg_first_excp;
>
>reg_second_invalid:
>
>    if (acctype & 0x0400)
>    {
>        regs->dat.raddr = sto | (0x8 >> 2);
>        cc = 2;
>        return cc;
>    }
>
>
>    goto reg_second_excp;
>
>reg_third_invalid:
>
>    if (acctype & 0x0400)
>    {
>        regs->dat.raddr = sto | (0x4 >> 2);
>        cc = 2;
>        return cc;
>    }
>
>
>    goto reg_third_excp;
>
>asce_type_excp:
>
>
>    regs->dat.xcode = 0x0038;
>    cc = 4;
>    goto tran_excp_addr;
>
>reg_first_excp:
>    regs->dat.xcode = 0x0039;
>    cc = 4;
>    goto tran_excp_addr;
>
>reg_second_excp:
>    regs->dat.xcode = 0x003A;
>    cc = 4;
>    goto tran_excp_addr;
>
>reg_third_excp:
>    regs->dat.xcode = 0x003B;
>    cc = 4;
>    goto tran_excp_addr;
>
>
>tran_excp_addr:
>
>    if (acctype & 0x0400)
>        return 3;
>
>
>    regs->ea.D = vaddr & 0xFFFFFFFFFFFFF000ULL;
>
>
>
>    if(regs->dat.stid == 0x001)
>    {
>        if ((regs->dat.asd & 0xFFFFFFFFFFFFF000ULL) == (regs->cr[(1)].D & 0xFFFFFFFFFFFFF000ULL))
>            regs->ea.D |= 0x000;
>        else if ((regs->dat.asd & 0xFFFFFFFFFFFFF000ULL) == (regs->cr[(7)].D & 0xFFFFFFFFFFFFF000ULL))
>            regs->ea.D |= 0x002;
>        else if ((regs->dat.asd & 0xFFFFFFFFFFFFF000ULL) == (regs->cr[(13)].D & 0xFFFFFFFFFFFFF000ULL))
>            regs->ea.D |= 0x003;
>        else
>            regs->ea.D |= 0x001;
>    }
>    else
>        regs->ea.D |= regs->dat.stid;
># 1759 "dat.h"
>    if (acctype & 0x0004) {
>        regs->ea.D |= 0x800;
>    } else if (acctype & (0x0002|0x0001)) {
>        regs->ea.D |= 0x400;
>    }
>
>
>
>    if (((&regs->psw)->asc == 0x40)
>     || (((regs)->sie_active) && ( ((((regs->guestregs))->siebk->mx) & (0x01)) && (((&(regs->guestregs)->psw)->asc & ( 1 << (6) )) != 0) ))
>       )
>       regs->excarid = arn > 15 ? 0 : arn;
>
>
>    return cc;
>
>}
>
>
>
>
>
>static inline void z900_purge_tlb (REGS *regs)
>{
>    do { if ((regs)->aie) { (regs)->psw.ia.D = ((U64)((((regs)))->aiv.D + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((0))) & ((((regs)))->psw.amask.D)); (regs)->aie = ((void *)0); } } while (0);
>    if (((++regs->tlbID) & 0x00000000003FFFFFULL) == 0)
>    {
>        memset (&regs->tlb.vaddr, 0, 1024 * sizeof(DW));
>        regs->tlbID = 1;
>    }
>
>
>    if(regs->host && regs->guestregs)
>    {
>        do { if ((regs->guestregs)->aie) { (regs->guestregs)->psw.ia.D = ((U64)((((regs->guestregs)))->aiv.D + ((intptr_t)(((regs->guestregs)))->ip - (intptr_t)(((regs->guestregs)))->aip) + ((0))) & ((((regs->guestregs)))->psw.amask.D)); (regs->guestregs)->aie = ((void *)0); } } while (0);
>        if (((++regs->guestregs->tlbID) & 0x00000000003FFFFFULL) == 0)
>        {
>            memset (&regs->guestregs->tlb.vaddr, 0, 1024 * sizeof(DW));
>            regs->guestregs->tlbID = 1;
>        }
>    }
>
>}
>
>
>
>
>
>static inline void z900_purge_tlb_all ()
>{
>int i;
>
>    for (i = 0; i < sysblk.maxcpu; i++)
>        if ((sysblk.regs[(i)] != ((void *)0))
>         && (sysblk.regs[i]->cpubit & sysblk.started_mask))
>            z900_purge_tlb (sysblk.regs[i]);
>
>}
>
>
>
>
>
>static inline void z900_purge_tlbe (REGS *regs, U64 pfra)
>{
>int i;
>U64 pte;
>U64 ptemask;
># 1840 "dat.h"
>    ptemask = (U64)0xFFFFFFFFFFFFF000ULL;
>    pte = pfra & ptemask;
>
>
>    do { if ((regs)->aie) { (regs)->psw.ia.D = ((U64)((((regs)))->aiv.D + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((0))) & ((((regs)))->psw.amask.D)); (regs)->aie = ((void *)0); } } while (0);
>    for (i = 0; i < 1024; i++)
>        if ((regs->tlb.pte[(i)].D & ptemask) == pte)
>            regs->tlb.vaddr[(i)].D &= 0xFFFFFFFFFFC00000ULL;
>
>
>
>    if (regs->host && regs->guestregs)
>    {
>        do { if ((regs->guestregs)->aie) { (regs->guestregs)->psw.ia.D = ((U64)((((regs->guestregs)))->aiv.D + ((intptr_t)(((regs->guestregs)))->ip - (intptr_t)(((regs->guestregs)))->aip) + ((0))) & ((((regs->guestregs)))->psw.amask.D)); (regs->guestregs)->aie = ((void *)0); } } while (0);
>        for (i = 0; i < 1024; i++)
>            if ((regs->guestregs->tlb.pte[(i)].D & ptemask) == pte)
>                regs->guestregs->tlb.vaddr[(i)].D &= 0xFFFFFFFFFFC00000ULL;
>    }
>    else
>
>    if (regs->guest)
>    {
>        do { if ((regs->hostregs)->aie) { (regs->hostregs)->psw.ia.D = ((U64)((((regs->hostregs)))->aiv.D + ((intptr_t)(((regs->hostregs)))->ip - (intptr_t)(((regs->hostregs)))->aip) + ((0))) & ((((regs->hostregs)))->psw.amask.D)); (regs->hostregs)->aie = ((void *)0); } } while (0);
>        for (i = 0; i < 1024; i++)
>            if ((regs->hostregs->tlb.pte[(i)].D & ptemask) == pte)
>                regs->hostregs->tlb.vaddr[(i)].D &= 0xFFFFFFFFFFC00000ULL;
>    }
>
>
>}
>
>
>
>
>
>static inline void z900_purge_tlbe_all (U64 pfra)
>{
>int i;
>
>    for (i = 0; i < sysblk.maxcpu; i++)
>        if ((sysblk.regs[(i)] != ((void *)0))
>         && (sysblk.regs[i]->cpubit & sysblk.started_mask))
>            z900_purge_tlbe (sysblk.regs[i], pfra);
>
>}
>
>
>
>
>
>static inline void z900_invalidate_tlb (REGS *regs, BYTE mask)
>{
>int i;
>
>    do { if ((regs)->aie) { (regs)->psw.ia.D = ((U64)((((regs)))->aiv.D + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((0))) & ((((regs)))->psw.amask.D)); (regs)->aie = ((void *)0); } } while (0);
>    if (mask == 0)
>        memset(&regs->tlb.acc, 0, 1024);
>    else
>        for (i = 0; i < 1024; i++)
>            if ((regs->tlb.vaddr[(i)].D & 0x00000000003FFFFFULL) == regs->tlbID)
>                regs->tlb.acc[i] &= mask;
>
>
>
>    if(regs->host && regs->guestregs)
>    {
>        do { if ((regs->guestregs)->aie) { (regs->guestregs)->psw.ia.D = ((U64)((((regs->guestregs)))->aiv.D + ((intptr_t)(((regs->guestregs)))->ip - (intptr_t)(((regs->guestregs)))->aip) + ((0))) & ((((regs->guestregs)))->psw.amask.D)); (regs->guestregs)->aie = ((void *)0); } } while (0);
>        if (mask == 0)
>            memset(&regs->guestregs->tlb.acc, 0, 1024);
>        else
>            for (i = 0; i < 1024; i++)
>                if ((regs->guestregs->tlb.vaddr[(i)].D & 0x00000000003FFFFFULL) == regs->guestregs->tlbID)
>                    regs->guestregs->tlb.acc[i] &= mask;
>    }
>    else
>
>    if(regs->guest)
>    {
>        do { if ((regs->hostregs)->aie) { (regs->hostregs)->psw.ia.D = ((U64)((((regs->hostregs)))->aiv.D + ((intptr_t)(((regs->hostregs)))->ip - (intptr_t)(((regs->hostregs)))->aip) + ((0))) & ((((regs->hostregs)))->psw.amask.D)); (regs->hostregs)->aie = ((void *)0); } } while (0);
>        if (mask == 0)
>            memset(&regs->hostregs->tlb.acc, 0, 1024);
>        else
>            for (i = 0; i < 1024; i++)
>                if ((regs->hostregs->tlb.vaddr[(i)].D & 0x00000000003FFFFFULL) == regs->hostregs->tlbID)
>                    regs->hostregs->tlb.acc[i] &= mask;
>    }
>
>
>}
># 1951 "dat.h"
>static inline void z900_invalidate_tlbe (REGS *regs, BYTE *main)
>{
>    int i;
>    int shift;
>    BYTE *mainwid;
>
>    if (main == ((void *)0))
>    {
>        z900_invalidate_tlb(regs, 0);
>        return;
>    }
>
>    mainwid = main + regs->tlbID;
>
>    do { if ((main) == (regs)->aip && (regs)->aie) { (regs)->psw.ia.D = ((U64)((((regs)))->aiv.D + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((0))) & ((((regs)))->psw.amask.D)); (regs)->aie = ((void *)0); } } while (0);
>    shift = regs->arch_mode == 0 ? 11 : 12;
>    for (i = 0; i < 1024; i++)
>        if ((BYTE*)((uintptr_t)(regs->tlb.main[i]) ^ (uintptr_t)((regs->tlb.vaddr[(i)].D | (i << shift))))
>
>                     == mainwid)
>        {
>            regs->tlb.acc[i] = 0;
>
>
>
>
>        }
>
>
>
>    if (regs->host && regs->guestregs)
>    {
>        do { if ((main) == (regs->guestregs)->aip && (regs->guestregs)->aie) { (regs->guestregs)->psw.ia.D = ((U64)((((regs->guestregs)))->aiv.D + ((intptr_t)(((regs->guestregs)))->ip - (intptr_t)(((regs->guestregs)))->aip) + ((0))) & ((((regs->guestregs)))->psw.amask.D)); (regs->guestregs)->aie = ((void *)0); } } while (0);
>        shift = regs->guestregs->arch_mode == 0 ? 11 : 12;
>        for (i = 0; i < 1024; i++)
>            if ((BYTE*)((uintptr_t)(regs->guestregs->tlb.main[i]) ^ (uintptr_t)((regs->guestregs->tlb.vaddr[(i)].D | (i << shift))))
>
>                         == mainwid)
>            {
>                regs->guestregs->tlb.acc[i] = 0;
>
>
>
>
>            }
>    }
>
>
>    if (regs->guest)
>    {
>        do { if ((main) == (regs->hostregs)->aip && (regs->hostregs)->aie) { (regs->hostregs)->psw.ia.D = ((U64)((((regs->hostregs)))->aiv.D + ((intptr_t)(((regs->hostregs)))->ip - (intptr_t)(((regs->hostregs)))->aip) + ((0))) & ((((regs->hostregs)))->psw.amask.D)); (regs->hostregs)->aie = ((void *)0); } } while (0);
>        shift = regs->hostregs->arch_mode == 0 ? 11 : 12;
>        for (i = 0; i < 1024; i++)
>            if ((BYTE*)((uintptr_t)(regs->hostregs->tlb.main[i]) ^ (uintptr_t)((regs->hostregs->tlb.vaddr[(i)].D | (i << shift))))
>
>                         == mainwid)
>            {
>                regs->hostregs->tlb.acc[i] = 0;
>
>
>
>
>            }
>    }
>
>
>
>}
># 2041 "dat.h"
>static inline void z900_invalidate_pte (BYTE ibyte, U64 op1,
>                                                    U32 op2, REGS *regs)
>{
>U64 raddr;
>U64 pte;
>U64 pfra;
>
>    ((ibyte)=(ibyte));
># 2124 "dat.h"
>    {
>
>
>
>        raddr = (op1 & 0xFFFFFFFFFFFFF800ULL)
>                    + ((op2 & 0x000FF000) >> 9);
>
>
>
>
>
>
>
>        pte = z900_vfetch8 ( raddr, 19, regs );
>
>
>
>
>        if(ibyte == 0x59)
>            pte &= ~0x100;
>        else
>
>            pte |= 0x400;
>        z900_vstore8 ( pte, raddr, 19, regs );
>        pfra = pte & 0xFFFFFFFFFFFFF000ULL;
>    }
>
>
>
>    z900_purge_tlbe_all (pfra);
>
>}
># 2165 "dat.h"
>static inline int z900_check_sa_per2 (int arn, int acctype, REGS *regs)
>{
>    ((acctype)=(acctype));
>    if((regs->dat.asd & 0x080) || !(regs->cr[(9)].D & 0x00200000))
>    {
>        regs->peraid = arn > 0 && arn < 16 ? arn : 0;
>        regs->perc |= regs->dat.stid;
>        return 1;
>    }
>    return 0;
>}
># 2210 "dat.h"
>static inline BYTE *z900_logical_to_main_l (U64 addr, int arn,
>                                    REGS *regs, int acctype, BYTE akey,
>                                    size_t len)
>{
>U64 aaddr;
>U64 apfra;
>int ix = (((U32)(addr) >> 12) & 0x3FF);
>
>
>    if ( ((((&regs->psw)->sysmask & 0x04)==0) || arn == 19)
>
>
>
>      && !(regs->sie_active
>
>
>
>
>
>
>          )
>
>       )
>    {
>        regs->dat.private = regs->dat.protect = 0;
>        regs->dat.raddr = addr;
>        regs->dat.rpfra = addr & 0xFFFFFFFFFFFFF000ULL;
>
>
>        regs->tlb.asd[(ix)].D = 0xFFFFFFFFFFFFFFFFULL;
>        regs->tlb.vaddr[(ix)].D = (addr & 0xFFFFFFFFFFC00000ULL) | regs->tlbID;
>        regs->tlb.pte[(ix)].D = addr & 0xFFFFFFFFFFC00000ULL;
>        regs->tlb.acc[ix] =
>        regs->tlb.common[ix] =
>        regs->tlb.protect[ix] = 0;
>    }
>    else {
>        if (z900_translate_addr (addr, arn, regs, acctype))
>            goto vabs_prog_check;
>    }
>
>    if (regs->dat.protect
>     && (acctype & (0x0002|0x0001)))
>        goto vabs_prot_excp;
>
>
>    regs->dat.aaddr = aaddr = ( (U64)((regs->dat.raddr) & 0xFFFFFFFFFFFFE000ULL) == (U64)0 || (U64)((regs->dat.raddr) & 0xFFFFFFFFFFFFE000ULL) == (regs->px.F.L.F) ? (regs->dat.raddr) ^ (regs->px.F.L.F) : (regs->dat.raddr) );
>    apfra=( (U64)((regs->dat.rpfra) & 0xFFFFFFFFFFFFE000ULL) == (U64)0 || (U64)((regs->dat.rpfra) & 0xFFFFFFFFFFFFE000ULL) == (regs->px.F.L.F) ? (regs->dat.rpfra) ^ (regs->px.F.L.F) : (regs->dat.rpfra) );
>
>
>    if (regs->dat.aaddr > regs->mainlim)
>        goto vabs_addr_excp;
>
>
>    if(__builtin_expect(((regs)->sie_mode),0)) regs->hostregs->dat.protect = 0;
>    if(__builtin_expect(((regs)->sie_mode),0) && !regs->sie_pref)
>    {
>
>        if (z900_translate_addr((regs->sie_mso + regs->dat.aaddr), ((arn > 0 && arn < 16 && ( ((((regs))->siebk->mx) & (0x01)) && (((&(regs)->psw)->asc & ( 1 << (6) )) != 0) )) ? arn : 18), (regs->hostregs), (0))
>
>                                                )
>            (regs->hostregs->program_interrupt) (regs->hostregs, regs->hostregs->dat.xcode);
>
>        regs->dat.protect |= regs->hostregs->dat.protect;
>        regs->tlb.protect[ix] |= regs->hostregs->dat.protect;
>
>        if ( (((&regs->psw)->sysmask & 0x04)==0) || (arn == 19) )
>            regs->tlb.pte[(ix)].D = addr & 0xFFFFFFFFFFC00000ULL;
>
>
>        if (arn > 0 && arn < 16 && ( ((((regs))->siebk->mx) & (0x01)) && (((&(regs)->psw)->asc & ( 1 << (6) )) != 0) ))
>        {
>            regs->tlb.asd[(ix)].D = regs->dat.asd;
>
>            regs->dat.private = regs->hostregs->dat.private;
>
>
>            regs->dat.asd = regs->hostregs->dat.asd ^ 0x800;
>            regs->cr[(16 + arn)].D = regs->dat.asd;
>            regs->aea_ar[arn] = 16 + arn;
>            regs->aea_common[16 + arn] = (regs->dat.asd & (0x100|0x020)) == 0;
>            regs->aea_aleprot[arn] = regs->hostregs->dat.protect & 2;
>        }
>
>
>        regs->hostregs->dat.aaddr = aaddr =
>              ( (U64)((regs->hostregs->dat.raddr) & 0xFFFFFFFFFFFFE000ULL) == (U64)0 || (U64)((regs->hostregs->dat.raddr) & 0xFFFFFFFFFFFFE000ULL) == (regs->hostregs->px.F.L.F) ? (regs->hostregs->dat.raddr) ^ (regs->hostregs->px.F.L.F) : (regs->hostregs->dat.raddr) );
>        apfra = ( (U64)((regs->hostregs->dat.rpfra) & 0xFFFFFFFFFFFFE000ULL) == (U64)0 || (U64)((regs->hostregs->dat.rpfra) & 0xFFFFFFFFFFFFE000ULL) == (regs->hostregs->px.F.L.F) ? (regs->hostregs->dat.rpfra) ^ (regs->hostregs->px.F.L.F) : (regs->hostregs->dat.rpfra) );
>
>        if(regs->hostregs->dat.aaddr > regs->hostregs->mainlim)
>            goto vabs_addr_excp;
># 2310 "dat.h"
>    }
>
>
>
>    regs->dat.storkey = &((regs)->storkeys[(aaddr)>>11]);
>
>
>
>    if (__builtin_expect((((regs)->sie_active)),0))
>        return regs->mainstor + aaddr;
>
>
>    if (__builtin_expect((acctype & 0x0004),1))
>    {
>
>        if (__builtin_expect((z900_is_fetch_protected (addr, *regs->dat.storkey, akey, regs)),0))
>        {
>            if (__builtin_expect(((regs)->sie_mode),0)) regs->hostregs->dat.protect = 0;
>            goto vabs_prot_excp;
>        }
>
>
>        *regs->dat.storkey |= 0x04;
>
>
>        regs->tlb.storkey[ix] = regs->dat.storkey;
>        regs->tlb.skey[ix] = *regs->dat.storkey & 0xF0;
>        regs->tlb.acc[ix] = 0x0004;
>        regs->tlb.main[ix] = (BYTE*)((uintptr_t)((regs)->mainstor + (uintptr_t)(apfra)) ^ (uintptr_t)((addr) & 0xFFFFFFFFFFFFF000ULL));
>
>    }
>    else
>    {
>
>        if (__builtin_expect((z900_is_store_protected (addr, *regs->dat.storkey, akey, regs)),0))
>        {
>            if (__builtin_expect(((regs)->sie_mode),0)) regs->hostregs->dat.protect = 0;
>            goto vabs_prot_excp;
>        }
>        if (__builtin_expect(((regs)->sie_mode),0) && regs->hostregs->dat.protect)
>            goto vabs_prot_excp;
>
>
>        if (acctype & 0x0002)
>            *regs->dat.storkey |= (0x04 | 0x02);
>
>
>        regs->tlb.storkey[ix] = regs->dat.storkey;
>        regs->tlb.skey[ix] = *regs->dat.storkey & 0xF0;
>        regs->tlb.acc[ix] = (addr >= 8192 || regs->dat.private)
>                              ? (0x0004|0x0001|acctype)
>                              : 0x0004;
>        regs->tlb.main[ix] = (BYTE*)((uintptr_t)((regs)->mainstor + (uintptr_t)(apfra)) ^ (uintptr_t)((addr) & 0xFFFFFFFFFFFFF000ULL));
>
>
>        if (( __builtin_expect(((regs)->permode),0) && ((regs)->ints_state & ( 1 << (21) )) ))
>        {
>            regs->tlb.acc[ix] = 0x0004;
>            if (arn != 19
>
>            && ( (((&regs->psw)->sysmask & 0x04)==0) ||
>               z900_check_sa_per2 (arn, acctype, regs)
>               )
>
>
>            && ( (((regs->cr[(11)].D) & 0xFFFFFFFFFFFFFFFFULL) >= ((regs->cr[(10)].D) & 0xFFFFFFFFFFFFFFFFULL)) ? (((addr) >= ((regs->cr[(10)].D) & 0xFFFFFFFFFFFFFFFFULL)) && (addr) <= ((regs->cr[(11)].D) & 0xFFFFFFFFFFFFFFFFULL)) || (((addr+(len-1)) >= ((regs->cr[(10)].D) & 0xFFFFFFFFFFFFFFFFULL)) && (addr+(len-1)) <= ((regs->cr[(11)].D) & 0xFFFFFFFFFFFFFFFFULL)) || (((addr) <= ((regs->cr[(10)].D) & 0xFFFFFFFFFFFFFFFFULL)) && (addr+(len-1)) >= ((regs->cr[(11)].D) & 0xFFFFFFFFFFFFFFFFULL)) : (((addr+(len-1)) >= ((regs->cr[(10)].D) & 0xFFFFFFFFFFFFFFFFULL)) || (addr) <= ((regs->cr[(11)].D) & 0xFFFFFFFFFFFFFFFFULL)) )
>            )
>                do { (regs)->ints_mask |= ( 1 << (21) ); } while (0);
>        }
>
>    }
>
>
>    return regs->mainstor + aaddr;
>
>vabs_addr_excp:
>    regs->program_interrupt (regs, 0x0005);
>
>vabs_prot_excp:
>
>    regs->ea.D = addr & 0xFFFFFFFFFFFFF000ULL;
>    if (regs->dat.protect && (acctype & (0x0002|0x0001)) )
>    {
>        regs->ea.D |= 0x004;
>
>        if (regs->dat.protect & 2)
>            regs->ea.D |= 0x008;
>
>    }
>    regs->ea.D |= regs->dat.stid;
>    regs->excarid = (arn > 0 && arn < 16 ? arn : 0);
>
>
>
>    if(__builtin_expect(((regs)->sie_mode),0) && regs->hostregs->dat.protect)
>    {
>
>        regs->hostregs->ea.D = regs->ea.D;
>        regs->hostregs->excarid = regs->excarid;
>
>        (regs->hostregs->program_interrupt) (regs->hostregs, 0x0004);
>    }
>    else
>
>        regs->program_interrupt (regs, 0x0004);
>
>vabs_prog_check:
>    regs->program_interrupt (regs, regs->dat.xcode);
>
>    return ((void *)0);
>}
>
>
>static inline BYTE *z900_logical_to_main (U64 addr, int arn,
>                                    REGS *regs, int acctype, BYTE akey)
>{
>    return z900_logical_to_main_l(addr,arn,regs,acctype,akey,1);
>}
># 735 "inline.h" 2
>
># 1 "vstore.h" 1
># 153 "vstore.h"
>static inline void z900_vstorec (void *src, BYTE len,
>                                        U64 addr, int arn, REGS *regs)
>{
>BYTE *main1, *main2;
>BYTE *sk;
>int len2;
>
>    if ( __builtin_expect((( (int)((addr) & 0x7FF)) <= ( 0x7FF - (len) )),1) )
>    {
>        memcpy(( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].D == (regs)->tlb.asd[((((U32)(addr) >> 12) & 0x3FF))].D) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 12) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 12) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0xFFFFFFFFFFC00000ULL) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 12) & 0x3FF))].D),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)(addr) >> 12) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( z900_logical_to_main_l ((addr), (arn), (regs), (0x0002), (regs->psw.pkey), (len+1)) ) ),
>               src, len + 1);
>        ;
>    }
>    else
>    {
>        len2 = 0x800 - (addr & 0x7FF);
>        main1 = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].D == (regs)->tlb.asd[((((U32)(addr) >> 12) & 0x3FF))].D) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 12) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 12) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0xFFFFFFFFFFC00000ULL) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 12) & 0x3FF))].D),1) && __builtin_expect(((0x0001) & (regs)->tlb.acc[(((U32)(addr) >> 12) & 0x3FF)]),1) ? ( ((0x0001) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( z900_logical_to_main_l ((addr), (arn), (regs), (0x0001), (regs->psw.pkey), (len2)) ) )
>                                     ;
>        sk = regs->dat.storkey;
>        main2 = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].D == (regs)->tlb.asd[((((U32)((addr + len2) & ((regs)->psw.amask.D)) >> 12) & 0x3FF))].D) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)((addr + len2) & ((regs)->psw.amask.D)) >> 12) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)((addr + len2) & ((regs)->psw.amask.D)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr + len2) & ((regs)->psw.amask.D)) & 0xFFFFFFFFFFC00000ULL) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)((addr + len2) & ((regs)->psw.amask.D)) >> 12) & 0x3FF))].D),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)((addr + len2) & ((regs)->psw.amask.D)) >> 12) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)((addr + len2) & ((regs)->psw.amask.D)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)((addr + len2) & ((regs)->psw.amask.D)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr + len2) & ((regs)->psw.amask.D)))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)((addr + len2) & ((regs)->psw.amask.D)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr + len2) & ((regs)->psw.amask.D)))) ) : ( z900_logical_to_main_l (((addr + len2) & ((regs)->psw.amask.D)), (arn), (regs), (0x0002), (regs->psw.pkey), (len+1-len2)) ) )
>
>                                                          ;
>        *sk |= (0x04 | 0x02);
>        memcpy (main1, src, len2);
>        memcpy (main2, (BYTE*)src + len2, len + 1 - len2);
>    }
>
>}
># 195 "vstore.h"
>static inline void z900_vstoreb (BYTE value, U64 addr,
>                                         int arn, REGS *regs)
>{
>BYTE *main1;
>
>    main1 = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].D == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0002)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0002)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( z900_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0002)), ((regs->psw.pkey)), (1)) ) );
>    *main1 = value;
>    ;
>
>}
># 219 "vstore.h"
>static void z900_vstore2_full(U16 value, U64 addr,
>                                              int arn, REGS *regs)
>{
>BYTE *main1, *main2;
>BYTE *sk;
>
>    main1 = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].D == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0001)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0001)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( z900_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0001)), ((regs->psw.pkey)), (1)) ) );
>    sk = regs->dat.storkey;
>    main2 = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].D == ((regs))->tlb.asd[((((U32)(((addr + 1) & ((regs)->psw.amask.D))) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)(((addr + 1) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)(((addr + 1) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]),1) && __builtin_expect(((((((addr + 1) & ((regs)->psw.amask.D))) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr + 1) & ((regs)->psw.amask.D))) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0002)) & ((regs))->tlb.acc[(((U32)(((addr + 1) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]),1) ? ( (((0x0002)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr + 1) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + 1) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + 1) & ((regs)->psw.amask.D))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + 1) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + 1) & ((regs)->psw.amask.D))))) ) : ( z900_logical_to_main_l ((((addr + 1) & ((regs)->psw.amask.D))), ((arn)), ((regs)), ((0x0002)), ((regs->psw.pkey)), (1)) ) )
>                                                ;
>    *sk |= (0x04 | 0x02);
>    *main1 = value >> 8;
>    *main2 = value & 0xFF;
>
>}
>
>
>static inline void z900_vstore2 (U16 value, U64 addr, int arn,
>                                                            REGS *regs)
>{
>
>    if (__builtin_expect((!((U32)addr & 1) || ((U32)addr & 0x7FF) != 0x7FF),1))
>    {
>        BYTE *mn;
>        mn = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].D == (regs)->tlb.asd[((((U32)(addr) >> 12) & 0x3FF))].D) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 12) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 12) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0xFFFFFFFFFFC00000ULL) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 12) & 0x3FF))].D),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)(addr) >> 12) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( z900_logical_to_main_l ((addr), (arn), (regs), (0x0002), (regs->psw.pkey), (2)) ) );
>        store_hw_noswap((mn), (__extension__ ({ unsigned short int __v, __x = (unsigned short int) ((value)); if (__builtin_constant_p (__x)) __v = ((unsigned short int) ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8))); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })));
>        ;
>    }
>    else
>        z900_vstore2_full(value, addr, arn, regs);
>}
># 264 "vstore.h"
>static void z900_vstore4_full(U32 value, U64 addr,
>                                              int arn, REGS *regs)
>{
>BYTE *main1, *main2;
>BYTE *sk;
>int len;
>BYTE temp[4];
>
>    len = 0x800 - (addr & 0x7FF);
>    main1 = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].D == (regs)->tlb.asd[((((U32)(addr) >> 12) & 0x3FF))].D) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 12) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 12) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0xFFFFFFFFFFC00000ULL) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 12) & 0x3FF))].D),1) && __builtin_expect(((0x0001) & (regs)->tlb.acc[(((U32)(addr) >> 12) & 0x3FF)]),1) ? ( ((0x0001) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( z900_logical_to_main_l ((addr), (arn), (regs), (0x0001), (regs->psw.pkey), (len)) ) );
>    sk = regs->dat.storkey;
>    main2 = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].D == (regs)->tlb.asd[((((U32)((addr + len) & ((regs)->psw.amask.D)) >> 12) & 0x3FF))].D) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)((addr + len) & ((regs)->psw.amask.D)) >> 12) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)((addr + len) & ((regs)->psw.amask.D)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr + len) & ((regs)->psw.amask.D)) & 0xFFFFFFFFFFC00000ULL) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)((addr + len) & ((regs)->psw.amask.D)) >> 12) & 0x3FF))].D),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)((addr + len) & ((regs)->psw.amask.D)) >> 12) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)((addr + len) & ((regs)->psw.amask.D)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)((addr + len) & ((regs)->psw.amask.D)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr + len) & ((regs)->psw.amask.D)))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)((addr + len) & ((regs)->psw.amask.D)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr + len) & ((regs)->psw.amask.D)))) ) : ( z900_logical_to_main_l (((addr + len) & ((regs)->psw.amask.D)), (arn), (regs), (0x0002), (regs->psw.pkey), (4-len)) ) )
>                                                ;
>    *sk |= (0x04 | 0x02);
>    store_fw_noswap((temp), __bswap_32 ((value)));
>    memcpy(main1, temp, len);
>    memcpy(main2, temp+len, 4-len);
>
>}
>
>
>static inline void z900_vstore4 (U32 value, U64 addr, int arn,
>                                                            REGS *regs)
>{
>
>    if(__builtin_expect((!((U32)addr & 0x03)),1) || (((U32)addr & 0x7ff) <= 0x7fc))
>    {
>        BYTE *mn;
>        mn = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].D == (regs)->tlb.asd[((((U32)(addr) >> 12) & 0x3FF))].D) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 12) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 12) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0xFFFFFFFFFFC00000ULL) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 12) & 0x3FF))].D),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)(addr) >> 12) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( z900_logical_to_main_l ((addr), (arn), (regs), (0x0002), (regs->psw.pkey), (4)) ) );
>        store_fw_noswap((mn), __bswap_32 ((value)));
>        ;
>    }
>    else
>        z900_vstore4_full(value,addr,arn,regs);
>}
># 316 "vstore.h"
>static void z900_vstore8_full(U64 value, U64 addr,
>                                              int arn, REGS *regs)
>{
>BYTE *main1, *main2;
>BYTE *sk;
>int len;
>BYTE temp[8];
>
>    len = 0x800 - (addr & 0x7FF);
>    main1 = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].D == (regs)->tlb.asd[((((U32)(addr) >> 12) & 0x3FF))].D) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 12) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 12) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0xFFFFFFFFFFC00000ULL) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 12) & 0x3FF))].D),1) && __builtin_expect(((0x0001) & (regs)->tlb.acc[(((U32)(addr) >> 12) & 0x3FF)]),1) ? ( ((0x0001) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( z900_logical_to_main_l ((addr), (arn), (regs), (0x0001), (regs->psw.pkey), (len)) ) );
>    sk = regs->dat.storkey;
>    main2 = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].D == (regs)->tlb.asd[((((U32)((addr + len) & ((regs)->psw.amask.D)) >> 12) & 0x3FF))].D) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)((addr + len) & ((regs)->psw.amask.D)) >> 12) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)((addr + len) & ((regs)->psw.amask.D)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr + len) & ((regs)->psw.amask.D)) & 0xFFFFFFFFFFC00000ULL) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)((addr + len) & ((regs)->psw.amask.D)) >> 12) & 0x3FF))].D),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)((addr + len) & ((regs)->psw.amask.D)) >> 12) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)((addr + len) & ((regs)->psw.amask.D)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)((addr + len) & ((regs)->psw.amask.D)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr + len) & ((regs)->psw.amask.D)))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)((addr + len) & ((regs)->psw.amask.D)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr + len) & ((regs)->psw.amask.D)))) ) : ( z900_logical_to_main_l (((addr + len) & ((regs)->psw.amask.D)), (arn), (regs), (0x0002), (regs->psw.pkey), (8-len)) ) )
>                                                ;
>    *sk |= (0x04 | 0x02);
>    store_dw_i686_noswap((temp),__bswap_64 ((value)));
>    memcpy(main1, temp, len);
>    memcpy(main2, temp+len, 8-len);
>
>}
>static inline void z900_vstore8 (U64 value, U64 addr, int arn,
>                                                            REGS *regs)
>{
>
>
>
>    if(__builtin_expect((!((U32)addr & 0x07)),1))
>    {
>
>        U64 *mn;
>        mn = (U64*)( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].D == (regs)->tlb.asd[((((U32)(addr) >> 12) & 0x3FF))].D) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 12) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 12) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0xFFFFFFFFFFC00000ULL) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 12) & 0x3FF))].D),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)(addr) >> 12) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( z900_logical_to_main_l ((addr), (arn), (regs), (0x0002), (regs->psw.pkey), (8)) ) );
>        if (regs->cpubit == regs->sysblk->started_mask)
>            *mn = __bswap_64 (value);
>        else
>        store_dw_i686_noswap((mn),__bswap_64 ((value)));
>    }
>    else
>
>    {
>
>
>
>
>
>        if(__builtin_expect((((U32)addr & 0x7ff) <= 0x7f8),1))
>        {
>
>            BYTE *mn;
>            mn = ( __builtin_expect(((regs)->aea_ar[(arn)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn)])].D == (regs)->tlb.asd[((((U32)(addr) >> 12) & 0x3FF))].D) || ((regs)->aea_common[(regs)->aea_ar[(arn)]] & (regs)->tlb.common[(((U32)(addr) >> 12) & 0x3FF)])),1) && __builtin_expect(((regs->psw.pkey) == 0 || (regs->psw.pkey) == (regs)->tlb.skey[(((U32)(addr) >> 12) & 0x3FF)]),1) && __builtin_expect(((((addr) & 0xFFFFFFFFFFC00000ULL) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr) >> 12) & 0x3FF))].D),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)(addr) >> 12) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr))) ) : ( z900_logical_to_main_l ((addr), (arn), (regs), (0x0002), (regs->psw.pkey), (8)) ) );
>
>            store_dw_i686_noswap((mn),__bswap_64 ((value)));
>        }
>        else
>
>            z900_vstore8_full(value,addr,arn,regs);
>    }
>    ;
>}
># 389 "vstore.h"
>static inline void z900_vfetchc (void *dest, BYTE len,
>                                        U64 addr, int arn, REGS *regs)
>{
>BYTE *main1, *main2;
>int len2;
>
>    main1 = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].D == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( z900_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>
>    if ( __builtin_expect((( (int)((addr) & 0x7FF)) <= ( 0x7FF - (len) )),1) )
>    {
>        ;
>        memcpy (dest, main1, len + 1);
>    }
>    else
>    {
>        len2 = 0x800 - (addr & 0x7FF);
>        main2 = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].D == ((regs))->tlb.asd[((((U32)(((addr + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)(((addr + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)(((addr + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]),1) && __builtin_expect(((((((addr + len2) & ((regs)->psw.amask.D))) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)(((addr + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + len2) & ((regs)->psw.amask.D))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + len2) & ((regs)->psw.amask.D))))) ) : ( z900_logical_to_main_l ((((addr + len2) & ((regs)->psw.amask.D))), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) )
>                                                               ;
>        memcpy (dest, main1, len2);
>        memcpy ((BYTE*)dest + len2, main2, len + 1 - len2);
>    }
>
>}
># 427 "vstore.h"
>static inline BYTE z900_vfetchb (U64 addr, int arn,
>                                         REGS *regs)
>{
>BYTE *mn;
>
>    ;
>    mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].D == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( z900_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>    return *mn;
>}
># 451 "vstore.h"
>static U16 z900_vfetch2_full (U64 addr, int arn,
>                                             REGS *regs)
>{
>BYTE *mn;
>U16 value;
>
>    mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].D == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( z900_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>    value = *mn << 8;
>    mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].D == ((regs))->tlb.asd[((((U32)(((addr + 1) & ((regs)->psw.amask.D))) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)(((addr + 1) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)(((addr + 1) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]),1) && __builtin_expect(((((((addr + 1) & ((regs)->psw.amask.D))) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr + 1) & ((regs)->psw.amask.D))) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)(((addr + 1) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr + 1) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + 1) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + 1) & ((regs)->psw.amask.D))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + 1) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + 1) & ((regs)->psw.amask.D))))) ) : ( z900_logical_to_main_l ((((addr + 1) & ((regs)->psw.amask.D))), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) )
>                                              ;
>    value |= *mn;
>    return value;
>
>}
>
>static inline U16 z900_vfetch2 (U64 addr, int arn, REGS *regs)
>{
>    if(__builtin_expect((!((U32)addr & 0x01)),1) || (((U32)addr & 0x7ff) !=0x7ff ))
>    {
>    BYTE *mn;
>        ;
>        mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].D == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( z900_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>        return (__extension__ ({ unsigned short int __v, __x = (unsigned short int) (fetch_hw_noswap((mn))); if (__builtin_constant_p (__x)) __v = ((unsigned short int) ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8))); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; }));
>    }
>    return(z900_vfetch2_full(addr,arn,regs));
>}
># 492 "vstore.h"
>static U32 z900_vfetch4_full (U64 addr, int arn,
>                                             REGS *regs)
>{
>BYTE *mn;
>int len;
>BYTE temp[8];
>
>    mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].D == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( z900_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>    memcpy(temp, mn, 4);
>    len = 0x800 - (addr & 0x7FF);
>    mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].D == ((regs))->tlb.asd[((((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]),1) && __builtin_expect(((((((addr + len) & ((regs)->psw.amask.D))) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + len) & ((regs)->psw.amask.D))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + len) & ((regs)->psw.amask.D))))) ) : ( z900_logical_to_main_l ((((addr + len) & ((regs)->psw.amask.D))), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) )
>                                              ;
>    memcpy(temp+len, mn, 4);
>    return __bswap_32 (fetch_fw_noswap((temp)));
>
>}
>
>static inline U32 z900_vfetch4 (U64 addr, int arn, REGS *regs)
>{
>    if ( (__builtin_expect((!((U32)addr & 0x03)),1) || (((U32)addr & 0x7ff) <= 0x7fc )))
>    {
>    BYTE *mn;
>        ;
>        mn=( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].D == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( z900_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>        return __bswap_32 (fetch_fw_noswap((mn)));
>    }
>    return(z900_vfetch4_full(addr,arn,regs));
>}
># 535 "vstore.h"
>static U64 z900_vfetch8_full (U64 addr, int arn,
>                                             REGS *regs)
>{
>BYTE *mn;
>int len;
>BYTE temp[16];
>
>
>    mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].D == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( z900_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>    memcpy(temp, mn, 8);
>    len = 0x800 - (addr & 0x7FF);
>    mn = ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].D == ((regs))->tlb.asd[((((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]),1) && __builtin_expect(((((((addr + len) & ((regs)->psw.amask.D))) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + len) & ((regs)->psw.amask.D))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + len) & ((regs)->psw.amask.D))))) ) : ( z900_logical_to_main_l ((((addr + len) & ((regs)->psw.amask.D))), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) )
>                                             ;
>    memcpy(temp+len, mn, 8);
>    return __bswap_64 (fetch_dw_i686_noswap((temp)));
>
>}
>
>static inline U64 z900_vfetch8 (U64 addr, int arn, REGS *regs)
>{
>
>    if(__builtin_expect((!((U32)addr & 0x07)),1))
>    {
>
>        U64 *mn;
>        ;
>        mn=(U64*)( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].D == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( z900_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>        if (regs->cpubit == regs->sysblk->started_mask)
>            return __bswap_64 (*mn);
>        return __bswap_64 (fetch_dw_i686_noswap((mn)));
>    }
>    else
>
>    {
>
>        if(__builtin_expect((((U32)addr & 0x7ff) <= 0x7f8),1))
>        {
>
>            BYTE *mn;
>            ;
>            mn=( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].D == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( z900_logical_to_main_l (((addr)), ((arn)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>            return __bswap_64 (fetch_dw_i686_noswap((mn)));
>        }
>    }
>
>    return z900_vfetch8_full(addr,arn,regs);
>}
># 623 "vstore.h"
>static inline BYTE * z900_instfetch (REGS *regs, int exec)
>{
>U64 addr;
>BYTE *ia;
>BYTE *dest;
>int pagesz;
>int offset;
>int len;
>
>    do { if ((regs->bear_ip)) { (regs)->bear = (regs)->aiv.D + (intptr_t)((regs->bear_ip) - (regs)->aip); (regs)->bear &= (((regs))->psw.amask.D); regs->bear_ip = ((void *)0); } } while (0);
>
>    addr = exec ? regs->et.D
>         : __builtin_expect((regs->aie == ((void *)0)),1) ? regs->psw.ia.D : ((U64)(((regs))->aiv.D + ((intptr_t)((regs))->ip - (intptr_t)((regs))->aip) + ((0))) & (((regs))->psw.amask.D));
>
>    offset = (int)(addr & 0x00000FFF);
>
>
>    if ( __builtin_expect((offset & 0x01),0) )
>    {
>        if (!exec) regs->instinvalid = 1;
>        regs->program_interrupt(regs, 0x0006);
>    }
>    pagesz = __builtin_expect((addr < 0x800),0) ? 0x800 : 4096;
>
>
>
>    if( __builtin_expect(((regs)->permode),0) )
>    {
>
>        regs->perc = 0x40
>                   | (regs->psw.amode64 << 7)
>                   | (regs->psw.amode << 5)
>                   | (!(((&regs->psw)->sysmask & 0x04)==0) ? 0x10 : 0)
>                   | ((((&regs->psw)->asc & ( 1 << (7) )) != 0) << 3)
>                   | ((((&regs->psw)->asc & ( 1 << (6) )) != 0) << 2);
>
>
>
>
>        if(!exec)
>            regs->peradr = addr;
>
>
>        if( ( __builtin_expect(((regs)->permode),0) && ((regs)->ints_state & ( 1 << (22) )) )
>          && ( (((regs->cr[(11)].D) & 0xFFFFFFFFFFFFFFFFULL) >= ((regs->cr[(10)].D) & 0xFFFFFFFFFFFFFFFFULL)) ? (((addr) >= ((regs->cr[(10)].D) & 0xFFFFFFFFFFFFFFFFULL)) && (addr) <= ((regs->cr[(11)].D) & 0xFFFFFFFFFFFFFFFFULL)) : (((addr) >= ((regs->cr[(10)].D) & 0xFFFFFFFFFFFFFFFFULL)) || (addr) <= ((regs->cr[(11)].D) & 0xFFFFFFFFFFFFFFFFULL)) ) )
>        {
>            do { (regs)->ints_mask |= ( 1 << (22) ); } while (0);
>
>
>
>
>            if ( ( __builtin_expect(((regs)->permode),0) && ((regs)->ints_state & ( 1 << (16) )) ) )
>            {
>                do { (regs)->ints_mask |= ( 1 << (16) ); } while (0);
>                regs->psw.ia.D = addr;
>                regs->psw.zeroilc = 1;
>                regs->program_interrupt(regs, 0x0080);
>            }
>
>        }
>
>        if (!exec && !regs->tracing
>         && regs->aie && regs->ip < regs->aip + pagesz - 5)
>            return regs->ip;
>    }
>
>
>    if (!exec) regs->instinvalid = 1;
>
>
>    ia = ( __builtin_expect((((regs))->aea_ar[((20))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((20))])].D == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((20))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( z900_logical_to_main_l (((addr)), ((20)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>
>
>    if ( offset + ((ia[0]) < 0x40 ? 2 : (ia[0]) < 0xc0 ? 4 : 6) > pagesz )
>    {
>
>        dest = exec ? regs->exinst : regs->inst;
>        memcpy (dest, ia, 4);
>        len = pagesz - offset;
>        offset = 0;
>        addr = (addr + len) & ((regs)->psw.amask.D);
>        ia = ( __builtin_expect((((regs))->aea_ar[((20))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((20))])].D == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((20))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( z900_logical_to_main_l (((addr)), ((20)), ((regs)), ((0x0004)), ((regs->psw.pkey)), (1)) ) );
>        if (!exec) regs->ip = ia - len;
>        memcpy(dest + len, ia, 4);
>    }
>    else
>    {
>        dest = ia;
>        if (!exec) regs->ip = ia;
>    }
>
>    if (!exec)
>    {
>        regs->instinvalid = 0;
>
>
>        regs->aiv.D = addr & 0xFFFFFFFFFFFFF000ULL;
>        regs->aip = (BYTE *)((uintptr_t)ia & ~0x00000FFF);
>        regs->aim = (uintptr_t)regs->aip ^ (uintptr_t)regs->aiv.D;
>        if (__builtin_expect((!regs->tracing && !regs->permode),1))
>            regs->aie = regs->aip + pagesz - 5;
>        else
>        {
>            regs->aie = (BYTE *)1;
>            if (regs->tracing)
>                z900_process_trace(regs);
>        }
>    }
>
>    return dest;
>
>}
># 852 "vstore.h"
>static inline void z900_move_chars (U64 addr1, int arn1,
>       BYTE key1, U64 addr2, int arn2, BYTE key2, int len, REGS *regs)
>{
>BYTE *dest1, *dest2;
>BYTE *source1, *source2;
>BYTE *sk1, *sk2;
>int len2, len3;
>
>    ;
>
>
>    if (__builtin_expect((len == 0),0))
>    {
>        source1 = ( __builtin_expect((((regs))->aea_ar[((arn2))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn2))])].D == ((regs))->tlb.asd[((((U32)((addr2)) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn2))]] & ((regs))->tlb.common[(((U32)((addr2)) >> 12) & 0x3FF)])),1) && __builtin_expect((((key2)) == 0 || ((key2)) == ((regs))->tlb.skey[(((U32)((addr2)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr2)) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr2)) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr2)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr2)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr2)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr2)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr2)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr2)))) ) : ( z900_logical_to_main_l (((addr2)), ((arn2)), ((regs)), ((0x0004)), ((key2)), (1)) ) );
>        dest1 = ( __builtin_expect((((regs))->aea_ar[((arn1))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn1))])].D == ((regs))->tlb.asd[((((U32)((addr1)) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn1))]] & ((regs))->tlb.common[(((U32)((addr1)) >> 12) & 0x3FF)])),1) && __builtin_expect((((key1)) == 0 || ((key1)) == ((regs))->tlb.skey[(((U32)((addr1)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr1)) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr1)) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0002)) & ((regs))->tlb.acc[(((U32)((addr1)) >> 12) & 0x3FF)]),1) ? ( (((0x0002)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr1)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr1)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr1)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr1)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr1)))) ) : ( z900_logical_to_main_l (((addr1)), ((arn1)), ((regs)), ((0x0002)), ((key1)), (1)) ) );
>        *dest1 = *source1;
>        ;
>        return;
>    }
>
>
>    source1 = ( __builtin_expect((((regs))->aea_ar[((arn2))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn2))])].D == ((regs))->tlb.asd[((((U32)((addr2)) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn2))]] & ((regs))->tlb.common[(((U32)((addr2)) >> 12) & 0x3FF)])),1) && __builtin_expect((((key2)) == 0 || ((key2)) == ((regs))->tlb.skey[(((U32)((addr2)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr2)) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr2)) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr2)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr2)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr2)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr2)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr2)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr2)))) ) : ( z900_logical_to_main_l (((addr2)), ((arn2)), ((regs)), ((0x0004)), ((key2)), (1)) ) );
>    dest1 = ( __builtin_expect(((regs)->aea_ar[(arn1)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(arn1)])].D == (regs)->tlb.asd[((((U32)(addr1) >> 12) & 0x3FF))].D) || ((regs)->aea_common[(regs)->aea_ar[(arn1)]] & (regs)->tlb.common[(((U32)(addr1) >> 12) & 0x3FF)])),1) && __builtin_expect(((key1) == 0 || (key1) == (regs)->tlb.skey[(((U32)(addr1) >> 12) & 0x3FF)]),1) && __builtin_expect(((((addr1) & 0xFFFFFFFFFFC00000ULL) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr1) >> 12) & 0x3FF))].D),1) && __builtin_expect(((0x0001) & (regs)->tlb.acc[(((U32)(addr1) >> 12) & 0x3FF)]),1) ? ( ((0x0001) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr1) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr1) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr1))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr1) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr1))) ) : ( z900_logical_to_main_l ((addr1), (arn1), (regs), (0x0001), (key1), (len+1)) ) );
>    sk1 = regs->dat.storkey;
># 889 "vstore.h"
>    if ( __builtin_expect((( (int)((addr1) & 0x7FF)) <= ( 0x7FF - (len) )),1) )
>    {
>        if ( __builtin_expect((( (int)((addr2) & 0x7FF)) <= ( 0x7FF - (len) )),1) )
>        {
>
>            concpy (regs, dest1, source1, len + 1);
>        }
>        else
>        {
>
>            len2 = 0x800 - (addr2 & 0x7FF);
>            source2 = ( __builtin_expect((((regs))->aea_ar[((arn2))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn2))])].D == ((regs))->tlb.asd[((((U32)(((addr2 + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn2))]] & ((regs))->tlb.common[(((U32)(((addr2 + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)])),1) && __builtin_expect((((key2)) == 0 || ((key2)) == ((regs))->tlb.skey[(((U32)(((addr2 + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]),1) && __builtin_expect(((((((addr2 + len2) & ((regs)->psw.amask.D))) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr2 + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)(((addr2 + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr2 + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr2 + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr2 + len2) & ((regs)->psw.amask.D))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr2 + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr2 + len2) & ((regs)->psw.amask.D))))) ) : ( z900_logical_to_main_l ((((addr2 + len2) & ((regs)->psw.amask.D))), ((arn2)), ((regs)), ((0x0004)), ((key2)), (1)) ) )
>                                                             ;
>            concpy (regs, dest1, source1, len2);
>            concpy (regs, dest1 + len2, source2, len - len2 + 1);
>        }
>        *sk1 |= (0x04 | 0x02);
>    }
>    else
>    {
>
>        len2 = 0x800 - (addr1 & 0x7FF);
>        dest2 = ( __builtin_expect((((regs))->aea_ar[((arn1))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn1))])].D == ((regs))->tlb.asd[((((U32)(((addr1 + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn1))]] & ((regs))->tlb.common[(((U32)(((addr1 + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)])),1) && __builtin_expect((((key1)) == 0 || ((key1)) == ((regs))->tlb.skey[(((U32)(((addr1 + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]),1) && __builtin_expect(((((((addr1 + len2) & ((regs)->psw.amask.D))) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr1 + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0001)) & ((regs))->tlb.acc[(((U32)(((addr1 + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]),1) ? ( (((0x0001)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr1 + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr1 + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr1 + len2) & ((regs)->psw.amask.D))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr1 + len2) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr1 + len2) & ((regs)->psw.amask.D))))) ) : ( z900_logical_to_main_l ((((addr1 + len2) & ((regs)->psw.amask.D))), ((arn1)), ((regs)), ((0x0001)), ((key1)), (1)) ) )
>                                                           ;
>        sk2 = regs->dat.storkey;
>
>        if ( __builtin_expect((( (int)((addr2) & 0x7FF)) <= ( 0x7FF - (len) )),1) )
>        {
>
>             concpy (regs, dest1, source1, len2);
>             concpy (regs, dest2, source1 + len2, len - len2 + 1);
>        }
>        else
>        {
>
>            len3 = 0x800 - (addr2 & 0x7FF);
>            source2 = ( __builtin_expect((((regs))->aea_ar[((arn2))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn2))])].D == ((regs))->tlb.asd[((((U32)(((addr2 + len3) & ((regs)->psw.amask.D))) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn2))]] & ((regs))->tlb.common[(((U32)(((addr2 + len3) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)])),1) && __builtin_expect((((key2)) == 0 || ((key2)) == ((regs))->tlb.skey[(((U32)(((addr2 + len3) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]),1) && __builtin_expect(((((((addr2 + len3) & ((regs)->psw.amask.D))) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr2 + len3) & ((regs)->psw.amask.D))) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)(((addr2 + len3) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr2 + len3) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr2 + len3) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr2 + len3) & ((regs)->psw.amask.D))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr2 + len3) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr2 + len3) & ((regs)->psw.amask.D))))) ) : ( z900_logical_to_main_l ((((addr2 + len3) & ((regs)->psw.amask.D))), ((arn2)), ((regs)), ((0x0004)), ((key2)), (1)) ) )
>                                                            ;
>            if (len2 == len3)
>            {
>
>                concpy (regs, dest1, source1, len2);
>                concpy (regs, dest2, source2, len - len2 + 1);
>            }
>            else if (len2 < len3)
>            {
>
>                concpy (regs, dest1, source1, len2);
>                concpy (regs, dest2, source1 + len2, len3 - len2);
>                concpy (regs, dest2 + len3 - len2, source2, len - len3 + 1);
>            }
>            else
>            {
>
>                concpy (regs, dest1, source1, len3);
>                concpy (regs, dest1 + len3, source2, len2 - len3);
>                concpy (regs, dest2, source2 + len2 - len3, len - len2 + 1);
>            }
>        }
>        *sk1 |= (0x04 | 0x02);
>        *sk2 |= (0x04 | 0x02);
>    }
>    ;
>
>}
># 988 "vstore.h"
>static inline void z900_move_charx (U64 addr1, int space1,
>       BYTE key1, U64 addr2, int space2, BYTE key2,
>       int len, REGS *regs)
>{
>BYTE *main1, *main2;
>int len1, len2, len3;
>
>
>    if (__builtin_expect((len == 0),0))
>        return;
>
>    ;
>
>
>    if (__builtin_expect((len == 1),0))
>    {
>        main2 = ( __builtin_expect((((regs))->aea_ar[((space2))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((space2))])].D == ((regs))->tlb.asd[((((U32)((addr2)) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((space2))]] & ((regs))->tlb.common[(((U32)((addr2)) >> 12) & 0x3FF)])),1) && __builtin_expect((((key2)) == 0 || ((key2)) == ((regs))->tlb.skey[(((U32)((addr2)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr2)) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr2)) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr2)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr2)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr2)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr2)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr2)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr2)))) ) : ( z900_logical_to_main_l (((addr2)), ((space2)), ((regs)), ((0x0004)), ((key2)), (1)) ) );
>        main1 = ( __builtin_expect((((regs))->aea_ar[((space1))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((space1))])].D == ((regs))->tlb.asd[((((U32)((addr1)) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((space1))]] & ((regs))->tlb.common[(((U32)((addr1)) >> 12) & 0x3FF)])),1) && __builtin_expect((((key1)) == 0 || ((key1)) == ((regs))->tlb.skey[(((U32)((addr1)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr1)) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr1)) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0002)) & ((regs))->tlb.acc[(((U32)((addr1)) >> 12) & 0x3FF)]),1) ? ( (((0x0002)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr1)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr1)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr1)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr1)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr1)))) ) : ( z900_logical_to_main_l (((addr1)), ((space1)), ((regs)), ((0x0002)), ((key1)), (1)) ) );
>        *main1 = *main2;
>        ;
>        return;
>    }
>
>
>    main2 = ( __builtin_expect((((regs))->aea_ar[((space2))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((space2))])].D == ((regs))->tlb.asd[((((U32)((addr2)) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((space2))]] & ((regs))->tlb.common[(((U32)((addr2)) >> 12) & 0x3FF)])),1) && __builtin_expect((((key2)) == 0 || ((key2)) == ((regs))->tlb.skey[(((U32)((addr2)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr2)) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr2)) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr2)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr2)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr2)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr2)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr2)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr2)))) ) : ( z900_logical_to_main_l (((addr2)), ((space2)), ((regs)), ((0x0004)), ((key2)), (1)) ) );
>    main1 = ( __builtin_expect(((regs)->aea_ar[(space1)]),1) && __builtin_expect((((regs)->cr[((regs)->aea_ar[(space1)])].D == (regs)->tlb.asd[((((U32)(addr1) >> 12) & 0x3FF))].D) || ((regs)->aea_common[(regs)->aea_ar[(space1)]] & (regs)->tlb.common[(((U32)(addr1) >> 12) & 0x3FF)])),1) && __builtin_expect(((key1) == 0 || (key1) == (regs)->tlb.skey[(((U32)(addr1) >> 12) & 0x3FF)]),1) && __builtin_expect(((((addr1) & 0xFFFFFFFFFFC00000ULL) | (regs)->tlbID) == (regs)->tlb.vaddr[((((U32)(addr1) >> 12) & 0x3FF))].D),1) && __builtin_expect(((0x0002) & (regs)->tlb.acc[(((U32)(addr1) >> 12) & 0x3FF)]),1) ? ( ((0x0002) & 0x0001) ? (regs)->dat.storkey = (regs)->tlb.storkey[(((U32)(addr1) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr1) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr1))) : (BYTE*)((uintptr_t)((regs)->tlb.main[(((U32)(addr1) >> 12) & 0x3FF)]) ^ (uintptr_t)((addr1))) ) : ( z900_logical_to_main_l ((addr1), (space1), (regs), (0x0002), (key1), (len)) ) );
>
>
>
>    while (len > 0)
>    {
>
>        len1 = __builtin_expect((( (int)((addr1) & 0x7FF)) <= ( 0x800 - (len) )),1) ? len :
>                (int)(0x800 - (addr1 & 0x7FF));
>        len2 = __builtin_expect((( (int)((addr2) & 0x7FF)) <= ( 0x800 - (len) )),1) ? len :
>                (int)(0x800 - (addr2 & 0x7FF));
>        len3 = len1 < len2 ? len1 : len2;
>
>
>        concpy (regs, main1, main2, len3);
>
>
>        addr1 = (addr1 + len3) & ((regs)->psw.amask.D);
>        addr2 = (addr2 + len3) & ((regs)->psw.amask.D);
>
>
>        len -= len3;
>
>
>        if (len == 0) break;
>
>
>
>        main2 = (addr2 & 0x7FF) ? main2 + len3 :
>                    ( __builtin_expect((((regs))->aea_ar[((space2))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((space2))])].D == ((regs))->tlb.asd[((((U32)((addr2)) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((space2))]] & ((regs))->tlb.common[(((U32)((addr2)) >> 12) & 0x3FF)])),1) && __builtin_expect((((key2)) == 0 || ((key2)) == ((regs))->tlb.skey[(((U32)((addr2)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr2)) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr2)) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0004)) & ((regs))->tlb.acc[(((U32)((addr2)) >> 12) & 0x3FF)]),1) ? ( (((0x0004)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr2)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr2)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr2)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr2)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr2)))) ) : ( z900_logical_to_main_l (((addr2)), ((space2)), ((regs)), ((0x0004)), ((key2)), (1)) ) );
>        main1 = (addr1 & 0x7FF) ? main1 + len3 :
>                    ( __builtin_expect((((regs))->aea_ar[((space1))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((space1))])].D == ((regs))->tlb.asd[((((U32)((addr1)) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((space1))]] & ((regs))->tlb.common[(((U32)((addr1)) >> 12) & 0x3FF)])),1) && __builtin_expect((((key1)) == 0 || ((key1)) == ((regs))->tlb.skey[(((U32)((addr1)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr1)) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr1)) >> 12) & 0x3FF))].D),1) && __builtin_expect((((0x0002)) & ((regs))->tlb.acc[(((U32)((addr1)) >> 12) & 0x3FF)]),1) ? ( (((0x0002)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr1)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr1)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr1)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr1)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr1)))) ) : ( z900_logical_to_main_l (((addr1)), ((space1)), ((regs)), ((0x0002)), ((key1)), (1)) ) );
>
>    }
>
>    ;
>
>}
># 1073 "vstore.h"
>static inline void z900_validate_operand (U64 addr, int arn,
>                                      int len, int acctype, REGS *regs)
>{
>
>    ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].D == ((regs))->tlb.asd[((((U32)((addr)) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)((addr)) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)((addr)) >> 12) & 0x3FF)]),1) && __builtin_expect((((((addr)) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)((addr)) >> 12) & 0x3FF))].D),1) && __builtin_expect((((acctype)) & ((regs))->tlb.acc[(((U32)((addr)) >> 12) & 0x3FF)]),1) ? ( (((acctype)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)((addr)) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)((addr)) >> 12) & 0x3FF)]) ^ (uintptr_t)(((addr)))) ) : ( z900_logical_to_main_l (((addr)), ((arn)), ((regs)), ((acctype)), ((regs->psw.pkey)), (1)) ) );
>
>
>    if ( __builtin_expect((( (int)((addr) & 0x7FF)) > ( 0x7FF - (len) )),0) )
>    {
>        ( __builtin_expect((((regs))->aea_ar[((arn))]),1) && __builtin_expect(((((regs))->cr[(((regs))->aea_ar[((arn))])].D == ((regs))->tlb.asd[((((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF))].D) || (((regs))->aea_common[((regs))->aea_ar[((arn))]] & ((regs))->tlb.common[(((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)])),1) && __builtin_expect((((regs->psw.pkey)) == 0 || ((regs->psw.pkey)) == ((regs))->tlb.skey[(((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]),1) && __builtin_expect(((((((addr + len) & ((regs)->psw.amask.D))) & 0xFFFFFFFFFFC00000ULL) | ((regs))->tlbID) == ((regs))->tlb.vaddr[((((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF))].D),1) && __builtin_expect((((acctype)) & ((regs))->tlb.acc[(((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]),1) ? ( (((acctype)) & 0x0001) ? ((regs))->dat.storkey = ((regs))->tlb.storkey[(((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)], (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + len) & ((regs)->psw.amask.D))))) : (BYTE*)((uintptr_t)(((regs))->tlb.main[(((U32)(((addr + len) & ((regs)->psw.amask.D))) >> 12) & 0x3FF)]) ^ (uintptr_t)((((addr + len) & ((regs)->psw.amask.D))))) ) : ( z900_logical_to_main_l ((((addr + len) & ((regs)->psw.amask.D))), ((arn)), ((regs)), ((acctype)), ((regs->psw.pkey)), (1)) ) )
>                                                  ;
>    }
>
>
>
>
>}
># 737 "inline.h" 2
># 43 "cpu.c" 2
>
>
>
>
>
>void z900_checkstop_cpu(REGS *regs)
>{
>    regs->cpustate=2;
>    regs->checkstop=1;
>    do { (regs)->ints_state |= ( 1 << (31) ); } while (0);
>}
>
>
>
>void z900_checkstop_config(void)
>{
>    int i;
>    for(i=0;i<sysblk.maxcpu;i++)
>    {
>        if((sysblk.regs[(i)] != ((void *)0)))
>        {
>            z900_checkstop_cpu(sysblk.regs[i]);
>        }
>    }
>    do { int i; CPU_BITMAP mask = (sysblk.waiting_mask); for (i = 0; mask; i++) { if (mask & 1) ptt_pthread_cond_signal((&sysblk.regs[i]->intcond),"cpu.c" ":" "67"); mask >>= 1; } } while (0);
>}
>
>
>
>
>void z900_store_psw (REGS *regs, BYTE *addr)
>{
>
>
>    if (!regs->psw.zeroilc)
>        do { if ((regs)->aie) (regs)->psw.ia.D = ((U64)((((regs)))->aiv.D + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((0))) & ((((regs)))->psw.amask.D)); } while (0);
># 128 "cpu.c"
>        store_fw_noswap((addr), __bswap_32 ((( (regs->psw.sysmask << 24) | ((regs->psw.pkey | regs->psw.states) << 16) | ( ( (regs->psw.asc) | (regs->psw.cc << 4) | (regs->psw.progmask) ) << 8 ) | (regs->psw.amode64 ? 0x01 : 0) | regs->psw.zerobyte ))))
># 139 "cpu.c"
>                  ;
>        store_fw_noswap((addr + 4), __bswap_32 ((( (regs->psw.amode ? 0x80000000 : 0 ) | regs->psw.zeroword ))))
>
>
>
>                  ;
>        store_dw_i686_noswap((addr + 8),__bswap_64 ((regs->psw.ia.D)));
>
>}
>
>
>
>
>
>int z900_load_psw (REGS *regs, BYTE *addr)
>{
>    do { if ((regs)->aie) { (regs)->psw.ia.D = ((U64)((((regs)))->aiv.D + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((0))) & ((((regs)))->psw.amask.D)); (regs)->aie = ((void *)0); } } while (0);
>
>    regs->psw.zeroilc = 1;
>
>    regs->psw.sysmask = addr[0];
>    regs->psw.pkey = (addr[1] & 0xF0);
>    regs->psw.states = (addr[1] & 0x0F);
>
>
>
>
>
>        do { (regs)->ints_mask = ( ( ( ( 1 << (31) ) | ( 1 << (1) ) | ( 1 << (3) ) ) ) | ( (((regs))->psw.sysmask & 0x02) ? ( 1 << (30) ) : 0 ) | ( (((&((regs))->psw)->states & ( 1 << (2) )) != 0) ? (((regs))->cr[(14)].D & ( ( 1 << (28) ) | ( 1 << (27) ) | ( 1 << (26) ) | ( 1 << (25) ) | ( 1 << (24) ) )) : 0 ) | ( ( ((((regs)))->psw.sysmask & 0x40) || (__builtin_expect((((((regs))))->sie_mode),0) && ((((regs)))->siebk->m & 0x01)) ) ? (((regs))->ints_mask & ( ( 1 << (23) ) | ( 1 << (22) ) | ( 1 << (21) ) | ( 1 << (20) ) | ( 1 << (19) ) | ( 1 << (16) ) )) : 0 ) | ( (((regs))->psw.sysmask & 0x01) ? (( (((regs)))->cr[(0)].D & ( ( 1 << (15) ) | ( 1 << (14) ) | ( 1 << (13) ) | ( 1 << (12) ) | ( 1 << (11) ) | ( 1 << (10) ) | ( 1 << (9) ) | ( 1 << (7) ) | ( 1 << (6) ) | ( 1 << (5) ) | ( 1 << (4) ) ))) : 0 ) | ( (((&((regs))->psw)->states & ( 1 << (1) )) != 0) ? ( 1 << (0) ) : 0 ) ); if ( ( (regs)->permode = ( (((regs))->psw.sysmask & 0x40) || (__builtin_expect(((((regs)))->sie_mode),0) && (((regs))->siebk->m & 0x01)) ) ) ) do { if (((regs))->aie) { ((regs))->psw.ia.D = ((U64)(((((regs))))->aiv.D + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((0))) & (((((regs))))->psw.amask.D)); ((regs))->aie = ((void *)0); } } while (0); } while (0);
>
>
>        regs->psw.intcode = 0;
>        regs->psw.asc = (addr[2] & 0xC0);
>        regs->psw.cc = (addr[2] & 0x30) >> 4;
>        regs->psw.progmask = (addr[2] & 0x0F);
>        regs->psw.amode = (addr[4] & 0x80) ? 1 : 0;
>
>
>        regs->psw.zerobyte = addr[3] & 0xFE;
>        regs->psw.amode64 = addr[3] & 0x01;
>        regs->psw.zeroword = __bswap_32 (fetch_fw_noswap((addr+4))) & 0x7FFFFFFF;
>        regs->psw.ia.D = __bswap_64 (fetch_dw_i686_noswap((addr + 8)));
>        regs->psw.amask.D = regs->psw.amode64 ? 0xFFFFFFFFFFFFFFFFULL
>                           : regs->psw.amode ? 0x7FFFFFFF : 0x00FFFFFF;
># 191 "cpu.c"
>        if ((addr[0] & 0xB8) != 0)
>            return 0x0006;
>
>
>
>        if ((((&regs->psw)->states & ( 1 << (3) )) != 0))
>            return 0x0006;
>
>
>        if (regs->psw.zerobyte)
>            return 0x0006;
>
>
>        if ( regs->psw.zeroword )
>            return 0x0006;
># 231 "cpu.c"
>        if (regs->psw.amode64 && !regs->psw.amode)
>            return 0x0006;
>
>
>        if (!regs->psw.amode && regs->psw.ia.D > 0x00FFFFFF)
>            return 0x0006;
>
>
>        if (!regs->psw.amode64 && regs->psw.ia.D > 0x7FFFFFFF)
>            return 0x0006;
># 281 "cpu.c"
>    regs->psw.zeroilc = 0;
>
>
>    if ((((&regs->psw)->states & ( 1 << (1) )) != 0) && ( (sysblk.insttrace && sysblk.traceaddr[0] == 0 && sysblk.traceaddr[1] == 0) || (sysblk.inststep && sysblk.stepaddr[0] == 0 && sysblk.stepaddr[1] == 0) ))
>    {
>        logmsg (("HHCCP043I Wait state PSW loaded: "));
>        display_psw (regs);
>    }
>
>    do { if ((regs)->aea_mode != ( ( (((&((regs))->psw)->sysmask & 0x04)==0) ? ((__builtin_expect((((((regs))))->sie_mode),0) && ((((((regs))))->siebk->mx) & (0x01)) ) && (((&((regs))->psw)->asc & ( 1 << (6) )) != 0) ? 2 : 0) : ((((regs))->psw.asc >> 6) + 1) ) | ( ( ((((regs)))->psw.sysmask & 0x40) || (__builtin_expect((((((regs))))->sie_mode),0) && ((((regs)))->siebk->m & 0x01)) ) ? 0x40 : 0 ) )) { do { int i; int inst_cr = ((regs))->aea_ar[20]; BYTE oldmode = ((regs))->aea_mode; ((regs))->aea_mode = ( ( (((&(((regs)))->psw)->sysmask & 0x04)==0) ? ((__builtin_expect(((((((regs)))))->sie_mode),0) && (((((((regs)))))->siebk->mx) & (0x01)) ) && (((&(((regs)))->psw)->asc & ( 1 << (6) )) != 0) ? 2 : 0) : (((((regs)))->psw.asc >> 6) + 1) ) | ( ( (((((regs))))->psw.sysmask & 0x40) || (__builtin_expect(((((((regs)))))->sie_mode),0) && (((((regs))))->siebk->m & 0x01)) ) ? 0x40 : 0 ) ); switch (((regs))->aea_mode & 0x0F) { case 1: ((regs))->aea_ar[20] = 1; for(i = 0; i < 16; i++) ((regs))->aea_ar[i] = 1; break; case 2: (((regs)))->aea_ar[20] = 1; for(i = 0; i < 16; i++) (((regs)))->aea_ar[i] = 1; for (i = 1; i < 16; i++) { if ((((regs)))->ar[(i)] == 1) (((regs)))->aea_ar[i] = 7; else if ((((regs)))->ar[(i)] != 0) (((regs)))->aea_ar[i] = 0; } break; case 3: (((regs)))->aea_ar[20] = 1; for(i = 0; i < 16; i++) (((regs)))->aea_ar[i] = 7; break; case 4: (((regs)))->aea_ar[20] = 13; for(i = 0; i < 16; i++) (((regs)))->aea_ar[i] = 13; break; default: ((regs))->aea_ar[20] = 32; for(i = 0; i < 16; i++) ((regs))->aea_ar[i] = 32; } if (inst_cr != ((regs))->aea_ar[20]) do { if ((((regs)))->aie) { (((regs)))->psw.ia.D = ((U64)((((((regs)))))->aiv.D + ((intptr_t)(((((regs)))))->ip - (intptr_t)(((((regs)))))->aip) + ((0))) & ((((((regs)))))->psw.amask.D)); (((regs)))->aie = ((void *)0); } } while (0); if ((oldmode & 0x40) == 0 && (((regs))->aea_mode & 0x40) != 0) { do { if ((((regs)))->aie) { (((regs)))->psw.ia.D = ((U64)((((((regs)))))->aiv.D + ((intptr_t)(((((regs)))))->ip - (intptr_t)(((((regs)))))->aip) + ((0))) & ((((((regs)))))->psw.amask.D)); (((regs)))->aie = ((void *)0); } } while (0); if (( __builtin_expect(((((regs)))->permode),0) && ((((regs)))->ints_state & ( 1 << (21) )) )) z900_invalidate_tlb(((regs)),~(0x0002|0x0001)); } } while (0); } } while (0);
>
>    return 0;
>}
>
>
>
>
>void (__attribute__ (( regparm(2) )) z900_program_interrupt) (REGS *regs, int pcode)
>{
>PSA_900 *psa;
>REGS *realregs;
>U64 px;
>int code;
>int ilc;
>
>
>void *zmoncode=((void *)0);
>
>
>
>
>
>
>int sie_ilc=0;
>
>
>int nointercept;
>
>
>
>
>char dxcstr[8]={0};
>
>static char *pgmintname[] = {
>                        "Operation exception",
>                        "Privileged-operation exception",
>                        "Execute exception",
>                        "Protection exception",
>                        "Addressing exception",
>                        "Specification exception",
>                        "Data exception",
>                        "Fixed-point-overflow exception",
>                        "Fixed-point-divide exception",
>                        "Decimal-overflow exception",
>                        "Decimal-divide exception",
>                        "HFP-exponent-overflow exception",
>                        "HFP-exponent-underflow exception",
>                        "HFP-significance exception",
>                        "HFP-floating-point-divide exception",
>                        "Segment-translation exception",
>                        "Page-translation exception",
>                        "Translation-specification exception",
>                        "Special-operation exception",
>                        "Pseudo-page-fault exception",
>                        "Operand exception",
>                        "Trace-table exception",
>                        "ASN-translation exception",
>                        "Page access exception",
>                        "Vector/Crypto operation exception",
>                        "Page state exception",
>                        "Page transition exception",
>                        "Space-switch event",
>                        "Square-root exception",
>                        "Unnormalized-operand exception",
>                        "PC-translation specification exception",
>                        "AFX-translation exception",
>                        "ASX-translation exception",
>                        "LX-translation exception",
>                        "EX-translation exception",
>                        "Primary-authority exception",
>                        "Secondary-authority exception",
>                        "LFX-translation exception",
>                        "LSX-translation exception",
>                        "ALET-specification exception",
>                        "ALEN-translation exception",
>                        "ALE-sequence exception",
>                        "ASTE-validity exception",
>                        "ASTE-sequence exception",
>                        "Extended-authority exception",
>                        "LSTE-sequence exception",
>                        "ASTE-instance exception",
>                        "Stack-full exception",
>                        "Stack-empty exception",
>                        "Stack-specification exception",
>                        "Stack-type exception",
>                        "Stack-operation exception",
>                        "Unassigned exception",
>                        "Unassigned exception",
>                        "Unassigned exception",
>                        "ASCE-type exception",
>                        "Region-first-translation exception",
>                        "Region-second-translation exception",
>                        "Region-third-translation exception",
>                        "Unassigned exception",
>                        "Unassigned exception",
>                        "Unassigned exception",
>                        "Unassigned exception",
>                        "Monitor event" };
>
>
>
>
>
>
>
>    if(regs->ghostregs)
>        longjmp(regs->progjmp, pcode);
>
>    do { if (pttclass & (0x0400)) ptt_pthread_trace(0x0400,"*PROG",(void *)(uintptr_t)(pcode),(void *)(uintptr_t)((U32)(regs->ea.D & 0xffffffff)),"cpu.c" ":" "399",(int)(regs->psw.ia.F.L.F)); } while(0);
>
>
>
>
>
>
>        realregs = __builtin_expect(((regs)->sie_mode),0)
>                 ? sysblk.regs[regs->cpuad]->guestregs
>                 : sysblk.regs[regs->cpuad];
>
>
>
>
>
>    realregs->instcount++;
>
>
>    if (sysblk.intowner == realregs->cpuad)
>        do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "418"); } while (0);
>    if (sysblk.mainowner == realregs->cpuad)
>        do { if ((realregs)->sysblk->mainowner == (realregs)->hostregs->cpuad) { (realregs)->sysblk->mainowner = 0xFFFF; ptt_pthread_mutex_unlock((&(realregs)->sysblk->mainlock),"cpu.c" ":" "420"); } } while (0);
>
>
>    do { if ((realregs)->aie) { (realregs)->psw.ia.D = ((U64)((((realregs)))->aiv.D + ((intptr_t)(((realregs)))->ip - (intptr_t)(((realregs)))->aip) + ((0))) & ((((realregs)))->psw.amask.D)); (realregs)->aie = ((void *)0); } } while (0);
>
>    if(realregs->sie_active)
>        do { if ((realregs->guestregs)->aie) { (realregs->guestregs)->psw.ia.D = ((U64)((((realregs->guestregs)))->aiv.D + ((intptr_t)(((realregs->guestregs)))->ip - (intptr_t)(((realregs->guestregs)))->aip) + ((0))) & ((((realregs->guestregs)))->psw.amask.D)); (realregs->guestregs)->aie = ((void *)0); } } while (0);
>
>
>
>    ilc = realregs->psw.zeroilc ? 0 : (__builtin_expect((!(realregs)->execflag),1) ? (realregs)->psw.ilc : (realregs)->exrl ? 6 : 4);
>    if (realregs->psw.ilc == 0 && !realregs->psw.zeroilc)
>    {
>
>
>        ilc = realregs->execflag ? realregs->exrl ? 6 : 4 : 2;
>        realregs->ip += ilc;
>        realregs->psw.ia.D += ilc;
>        realregs->psw.ilc = ilc;
>    }
>
>    if(realregs->sie_active)
>    {
>        sie_ilc = realregs->guestregs->psw.zeroilc
>                ? 0 : (__builtin_expect((!(realregs->guestregs)->execflag),1) ? (realregs->guestregs)->psw.ilc : (realregs->guestregs)->exrl ? 6 : 4);
>        if (realregs->guestregs->psw.ilc == 0
>         && !realregs->guestregs->psw.zeroilc)
>        {
>            sie_ilc = realregs->guestregs->execflag ?
>                      realregs->guestregs->exrl ? 6 : 4 : 2;
>            realregs->guestregs->psw.ia.D += sie_ilc;
>            realregs->guestregs->psw.ilc = sie_ilc;
>        }
>    }
>
>
>
>    realregs->execflag = 0;
>
>    if(realregs->sie_active)
>        realregs->guestregs->execflag = 0;
>
>
>
>    if (realregs->cpuad == sysblk.mainowner)
>        do { if ((realregs)->sysblk->mainowner == (realregs)->hostregs->cpuad) { (realregs)->sysblk->mainowner = 0xFFFF; ptt_pthread_mutex_unlock((&(realregs)->sysblk->mainlock),"cpu.c" ":" "465"); } } while (0);
>
>
>
>
>
>    code = pcode & ~0x0080;
>
>
>
>    if( ( (realregs)->ints_state & (realregs)->ints_mask & ( ( 1 << (23) ) | ( 1 << (22) ) | ( 1 << (21) ) | ( 1 << (20) ) | ( 1 << (19) ) | ( 1 << (16) ) ) ) )
>        pcode |= 0x0080;
>
>
>    do { } while (0);
>    do { } while (0);
>
>
>
>
>    if(realregs->sie_active &&
>        (code == 0x0004
>      || code == 0x0005
>
>      || code == 0x0028
>      || code == 0x0029
>      || code == 0x002A
>      || code == 0x002D
>
>        ) )
>    {
>
>
>
>        realregs->guestregs->ea.D = realregs->ea.D;
>        realregs->guestregs->excarid = realregs->excarid;
>        realregs->guestregs->opndrid = realregs->opndrid;
>
>        realregs->guestregs->hostint = 1;
>
>        (realregs->guestregs->program_interrupt) (realregs->guestregs, pcode);
>    }
>
>
>
>
>    if ((code == 0x0011
>      || code == 0x0010
>
>      || code == 0x0038
>      || code == 0x0039
>      || code == 0x003A
>      || code == 0x003B
>
>      || code == 0x0016
>      || code == 0x0020
>      || code == 0x0021
>      || code == 0x0022
>      || code == 0x0026
>      || code == 0x0027
>      || code == 0x002E
>      || code == 0x0023
>      || code == 0x0024
>      || code == 0x0025
>      || code == 0x0029
>      || code == 0x002A
>      || code == 0x002B
>      || code == 0x002C
>      || code == 0x002F
>      || code == 0x002D
>      || code == 0x0030
>      || code == 0x0031
>      || code == 0x0032
>      || code == 0x0033
>      || code == 0x0034
>      || code == 0x0019)
>      && !realregs->instinvalid)
>    {
>        realregs->psw.ia.D -= ilc;
>        realregs->psw.ia.D &= ((realregs)->psw.amask.D);
>
>
>
>        if(realregs->sie_active && !realregs->guestregs->instinvalid)
>        {
>            realregs->guestregs->psw.ia.D -= sie_ilc;
>            realregs->guestregs->psw.ia.D &= ((realregs->guestregs)->psw.amask.D);
>        }
>
>    }
>
>
>
>    if(realregs->instinvalid &&
>      ( code == 0x0004
>      || code == 0x0005
>      || code == 0x0006
>      || code == 0x0012 ))
>    {
>        realregs->psw.ia.D += ilc;
>        realregs->psw.ia.D &= ((realregs)->psw.amask.D);
>    }
>
>
>    realregs->psw.intcode = pcode;
>
>
>    ((debug_program_interrupt) ? (debug_program_interrupt) ((regs),(pcode)) : (((void *)0)));
>
>
>    if(code && (( __builtin_expect(((realregs)->tracing),0) && (( sysblk.inststep && ( (sysblk.stepaddr[0] == 0 && sysblk.stepaddr[1] == 0) || (sysblk.stepaddr[0] <= sysblk.stepaddr[1] && ((U64)(((((realregs))))->aiv.D + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.D)) >= sysblk.stepaddr[0] && ((U64)(((((realregs))))->aiv.D + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.D)) <= sysblk.stepaddr[1] ) || (sysblk.stepaddr[0] > sysblk.stepaddr[1] && ((U64)(((((realregs))))->aiv.D + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.D)) >= sysblk.stepaddr[1] && ((U64)(((((realregs))))->aiv.D + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.D)) <= sysblk.stepaddr[0] ) ) ) || ( sysblk.insttrace && ( (sysblk.traceaddr[0] == 0 && sysblk.traceaddr[1] == 0) || (sysblk.traceaddr[0] <= sysblk.traceaddr[1] && ((U64)(((((realregs))))->aiv.D + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.D)) >= sysblk.traceaddr[0] && ((U64)(((((realregs))))->aiv.D + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.D)) <= sysblk.traceaddr[1] ) || (sysblk.traceaddr[0] > sysblk.traceaddr[1] && ((U64)(((((realregs))))->aiv.D + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.D)) >= sysblk.traceaddr[1] && ((U64)(((((realregs))))->aiv.D + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.D)) <= sysblk.traceaddr[0] ) ) )) )
>        || sysblk.pgminttr & ((U64)1 << ((code - 1) & 0x3F))))
>    {
>     BYTE *ip;
># 588 "cpu.c"
>        logmsg(("HHCCP014I "));
>
>        if(__builtin_expect(((realregs)->sie_mode),0))
>            logmsg(("SIE: "));
>
>
>
>
>        if (code == 0x0007)
>            sprintf(dxcstr, " DXC=%2.2X", regs->dxc);
>        logmsg (("CPU%4.4X: %s CODE=%4.4X ILC=%d%s\n"), realregs->cpuad,
>                pgmintname[ (code - 1) & 0x3F], pcode, ilc, dxcstr);
>
>
>        ip = realregs->instinvalid ? ((void *)0)
>           : (realregs->ip - ilc < realregs->aip)
>             ? realregs->inst : realregs->ip - ilc;
>
>        z900_display_inst (realregs, ip);
>    }
>
>    realregs->instinvalid = 0;
>
>
>
>    if(realregs->sie_active)
>        z900_sie_exit (realregs, (-3));
>
>
>
>    px = realregs->px.F.L.F;
>
>
>
>    if(__builtin_expect(((regs)->sie_mode),0))
>        px = regs->sie_px;
>
>
>
>    if(!__builtin_expect(((regs)->sie_mode),0) ||
>
>      (
>
>         !(code == 0x0004
>           && (!(((regs)->siebk->ec[2]) & (0x20))
>             || realregs->hostint))
>
>
>
>
>      && !((pcode & 0x0080) && (((regs)->siebk->m) & (0x01)))
>
>      && code != 0x0005
>      && code != 0x0006
>      && code != 0x0013
># 655 "cpu.c"
>      && !(code == 0x0001
>        && (((regs)->siebk->ic[0]) & (0x80)))
>      && !(code == 0x0002
>        && (((regs)->siebk->ic[0]) & (0x40)))
>
>      && !(code == 0x0007
>        && (regs->dxc == 1 || regs->dxc == 2)
>        && (regs->cr[(0)].D & 0x00040000)
>        && !(regs->hostregs->cr[(0)].D & 0x00040000))
>
>
>      && !(((regs)->siebk->ic[0]) & (0x20)) )
>    )
>    {
>
>
>        (regs)->storkeys[(px)>>11] |= (0x04 | 0x02);
>
>
>        psa = (void*)(regs->mainstor + px);
>
>
>
>        if(code == 0x0040)
>        {
>            zmoncode=psa->moncode;
>        }
>
>        nointercept = 1;
>    }
>    else
>    {
>
>
>
>        if(code != 0x0001)
>        {
>            psa = (void*)(regs->hostregs->mainstor + ((regs)->sie_state) + 0x40);
>
>            (regs->hostregs)->storkeys[(((regs)->sie_state))>>11] |= (0x04 | 0x02);
>
>
>            if(code == 0x0040)
>            {
>                PSA_900 *_psa;
>                _psa=(void *)(regs->hostregs->mainstor + ((regs)->sie_state) + 0x30);
>                zmoncode=_psa->ioid;
>            }
>
>        }
>        else
>        {
>
>            psa = (void*)(regs->mainstor + px);
>
>
>            (regs)->storkeys[(px)>>11] |= (0x04 | 0x02);
>        }
>
>        nointercept = 0;
>    }
>
>
>
>
>
>
>    if ( ( (realregs)->ints_mask & ( 1 << (21) ) ) && !( (realregs)->ints_mask & ( 1 << (19) ) ) &&
>                                   (realregs->ip[0] != 0x0E) &&
>         !(code == 0x00 || code == 0x06 || code == 0x08 || code == 0x0A ||
>           code == 0x0C || code == 0x0D || code == 0x0E || code == 0x1C ||
>           code == 0x40) )
>              do { (realregs)->ints_mask &= ~( 1 << (21) ); } while (0);
>
>    if( ( (realregs)->ints_state & (realregs)->ints_mask & ( ( 1 << (23) ) | ( 1 << (22) ) | ( 1 << (21) ) | ( 1 << (20) ) | ( 1 << (19) ) | ( 1 << (16) ) ) ) )
>    {
>        if( ( __builtin_expect(((realregs)->tracing),0) && (( sysblk.inststep && ( (sysblk.stepaddr[0] == 0 && sysblk.stepaddr[1] == 0) || (sysblk.stepaddr[0] <= sysblk.stepaddr[1] && ((U64)(((((realregs))))->aiv.D + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.D)) >= sysblk.stepaddr[0] && ((U64)(((((realregs))))->aiv.D + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.D)) <= sysblk.stepaddr[1] ) || (sysblk.stepaddr[0] > sysblk.stepaddr[1] && ((U64)(((((realregs))))->aiv.D + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.D)) >= sysblk.stepaddr[1] && ((U64)(((((realregs))))->aiv.D + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.D)) <= sysblk.stepaddr[0] ) ) ) || ( sysblk.insttrace && ( (sysblk.traceaddr[0] == 0 && sysblk.traceaddr[1] == 0) || (sysblk.traceaddr[0] <= sysblk.traceaddr[1] && ((U64)(((((realregs))))->aiv.D + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.D)) >= sysblk.traceaddr[0] && ((U64)(((((realregs))))->aiv.D + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.D)) <= sysblk.traceaddr[1] ) || (sysblk.traceaddr[0] > sysblk.traceaddr[1] && ((U64)(((((realregs))))->aiv.D + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.D)) >= sysblk.traceaddr[1] && ((U64)(((((realregs))))->aiv.D + ((intptr_t)((((realregs))))->ip - (intptr_t)((((realregs))))->aip) + ((-((ilc))))) & (((((realregs))))->psw.amask.D)) <= sysblk.traceaddr[0] ) ) )) ) )
>            logmsg(("HHCCP015I CPU%4.4X PER event: code=%4.4X perc=%2.2X " "addr=" "%16.16""ll""X" "\n")
>                                         ,
>              regs->cpuad, pcode, ( (realregs)->ints_mask & ( ( 1 << (23) ) | ( 1 << (22) ) | ( 1 << (21) ) | ( 1 << (20) ) | ( 1 << (19) ) | ( 1 << (16) ) ) ) >> 16,
>              (realregs->psw.ia.D - ilc) & ((realregs)->psw.amask.D) );
>
>        realregs->perc |= ( (realregs)->ints_state & (realregs)->ints_mask & ( ( 1 << (23) ) | ( 1 << (22) ) | ( 1 << (21) ) | ( 1 << (20) ) | ( 1 << (19) ) | ( 1 << (16) ) ) ) >> ((32 - 8) - 16);
>
>
>
>
>        if( !(( (realregs)->ints_state & (realregs)->ints_mask & ( 1 << (21) ) ))
>          || (( (realregs)->ints_state & (realregs)->ints_mask & ( 1 << (19) ) )) )
>            realregs->perc &= 0xFFFC;
>
>        store_hw_noswap((psa->perint), (__extension__ ({ unsigned short int __v, __x = (unsigned short int) ((realregs->perc)); if (__builtin_constant_p (__x)) __v = ((unsigned short int) ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8))); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })));
>
>        store_dw_i686_noswap((psa->peradr),__bswap_64 ((realregs->peradr)));
>
>        if( ( (realregs)->ints_mask & ( 1 << (21) ) ) && ((&realregs->psw)->asc == 0x40) )
>            psa->perarid = realregs->peraid;
>
>
>
>        if(nointercept)
>            do { (realregs)->ints_mask &= ~( ( 1 << (23) ) | ( 1 << (22) ) | ( 1 << (21) ) | ( 1 << (20) ) | ( 1 << (19) ) | ( 1 << (16) ) ); } while (0);
>
>    }
>    else
>    {
>        pcode &= 0xFF7F;
>    }
>
>
>
>
>
>
>
>    {
>
>        psa->pgmint[0] = 0;
>        psa->pgmint[1] = ilc;
>        store_hw_noswap((psa->pgmint + 2), (__extension__ ({ unsigned short int __v, __x = (unsigned short int) ((pcode)); if (__builtin_constant_p (__x)) __v = ((unsigned short int) ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8))); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })));
>
>
>        if ( code == 0x0011
>          || code == 0x0010
>
>          || code == 0x0038
>          || code == 0x0039
>          || code == 0x003A
>          || code == 0x003B
>
>          || code == 0x0029
>          || code == 0x002A
>          || code == 0x002B
>          || code == 0x002C
>          || code == 0x002F
>          || code == 0x002D
>
>          || code == 0x0004
>
>           )
>        {
>            psa->excarid = regs->excarid;
>            if(regs->ea.D | 0x004)
>                psa->opndrid = regs->opndrid;
>            realregs->opndrid = 0;
>        }
>
>
>
>        if ( code == 0x0011
>          || code == 0x0010
>          || code == 0x0038
>          || code == 0x0039
>          || code == 0x003A
>          || code == 0x003B
>
>          || code == 0x0004
>
>           )
>        {
>            store_dw_i686_noswap((psa->tea.D),__bswap_64 ((regs->ea.D)));
>        }
>
>
>        if ( code == 0x0020
>          || code == 0x0021
>          || code == 0x0024
>          || code == 0x0025
>          || code == 0x001C
>          || code == 0x0022
>          || code == 0x0026
>          || code == 0x0027
>          || code == 0x002E
>          || code == 0x0023)
>        {
>            store_fw_noswap((psa->tea.F.L.F), __bswap_32 ((regs->ea.D)));
>        }
># 851 "cpu.c"
>        realregs->ea.D = 0;
>
>
>        if (code == 0x0007)
>        {
>            store_fw_noswap((psa->dataexc), __bswap_32 ((regs->dxc)));
>
>
>            if(regs->cr[(0)].D & 0x00040000)
>            {
>                regs->fpc &= ~(0x0000FF00);
>                regs->fpc |= ((regs->dxc << 8)) & 0x0000FF00;
>            }
>
>        }
>
>
>        if (code == 0x0040)
>        {
>            store_hw_noswap((psa->monclass), (__extension__ ({ unsigned short int __v, __x = (unsigned short int) ((regs->monclass)); if (__builtin_constant_p (__x)) __v = ((unsigned short int) ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8))); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })));
># 890 "cpu.c"
>            store_dw_i686_noswap((zmoncode),__bswap_64 ((regs->mc.D)));
>
>
>
>        }
>
>
>
>        do { if ((regs->bear_ip)) { (regs)->bear = (regs)->aiv.D + (intptr_t)((regs->bear_ip) - (regs)->aip); (regs)->bear &= (((regs))->psw.amask.D); regs->bear_ip = ((void *)0); } } while (0);
>        store_dw_i686_noswap((psa->bea),__bswap_64 ((regs->bear)));
>
>
>    }
>
>
>    realregs->hostint = 0;
>
>
>
>    if(nointercept)
>    {
>
>
>
>
>
>        z900_store_psw (realregs, psa->pgmold);
>
>
>        if ( (code = z900_load_psw (realregs, psa->pgmnew)) )
>        {
>
>            if(__builtin_expect(((realregs)->sie_mode),0))
>            {
>
>                longjmp(realregs->progjmp, pcode);
>            }
>            else
>
>            {
>                logmsg (("HHCCP016I CPU%4.4X: Program interrupt loop: "),
>                          realregs->cpuad);
>                display_psw (realregs);
>                do { REGS *_regs = (realregs); if ((_regs)) (_regs)->hostregs->intwait = 1; ptt_pthread_mutex_lock((&sysblk.intlock),"cpu.c" ":" "933"); if ((_regs)) { while (sysblk.syncing) { sysblk.sync_mask &= ~(_regs)->hostregs->cpubit; if (!sysblk.sync_mask) ptt_pthread_cond_signal((&sysblk.sync_cond),"cpu.c" ":" "933"); ptt_pthread_cond_wait((&sysblk.sync_bc_cond),(&sysblk.intlock),"cpu.c" ":" "933"); } (_regs)->hostregs->intwait = 0; sysblk.intowner = (_regs)->hostregs->cpuad; } else sysblk.intowner = 0xFFFE; } while (0);
>                realregs->cpustate = 2;
>                do { (realregs)->ints_state |= ( 1 << (31) ); } while (0);
>                do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "936"); } while (0);
>            }
>        }
>
>
>
>        longjmp(realregs->progjmp, (-1));
>
>
>    }
>
>    longjmp (realregs->progjmp, pcode);
>
>
>}
>
>
>
>
>static void z900_restart_interrupt (REGS *regs)
>{
>int rc;
>PSA_900 *psa;
>
>    do { if (pttclass & (0x0100)) ptt_pthread_trace(0x0100,"*RESTART",(void *)(uintptr_t)(regs->cpuad),(void *)(uintptr_t)(regs->cpustate),"cpu.c" ":" "960",(int)(regs->psw.ia.F.L.F)); } while(0);
>
>
>    (regs)->storkeys[(regs->px.F.L.F)>>11] |= (0x04 | 0x02);
>
>
>    regs->psw.intcode = 0;
>
>
>    psa = (PSA_900*)(regs->mainstor + regs->px.F.L.F);
>
>
>    z900_store_psw (regs, psa->rstold);
>
>
>    rc = z900_load_psw (regs, psa->rstnew);
>
>    if ( rc == 0)
>    {
>        regs->opinterv = 0;
>        regs->cpustate = 1;
>    }
>
>    do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "983"); } while (0);
>
>    if ( rc )
>        regs->program_interrupt(regs, rc);
>
>    longjmp (regs->progjmp, (-10));
>}
>
>
>
>
>
>
>void z900_perform_io_interrupt (REGS *regs)
>{
>int rc;
>int icode;
>PSA_900 *psa;
>U32 ioparm;
>U32 ioid;
>U32 iointid;
>U64 pfx;
>DBLWRD csw;
>
>
>    icode = z900_present_io_interrupt (regs, &ioid, &ioparm, &iointid, csw);
>
>
>    if (icode == 0) return;
>
>    do { if (pttclass & (0x4000)) ptt_pthread_trace(0x4000,"*IOINT",(void *)(uintptr_t)(ioid),(void *)(uintptr_t)(ioparm),"cpu.c" ":" "1013",(int)(iointid)); } while(0);
>
>
>    if(__builtin_expect(((regs)->sie_mode),0) && icode != (-1))
>    {
>
>        psa = (void*)(regs->hostregs->mainstor + ((regs)->sie_state) + 0x30);
>        (regs->hostregs)->storkeys[(((regs)->sie_state))>>11] |= (0x04 | 0x02);
>    }
>    else
>
>    {
>
>        pfx =
>
>              __builtin_expect(((regs)->sie_mode),0) ? regs->sie_px :
>
>              regs->px.F.L.F;
>        psa = (void*)(regs->mainstor + pfx);
>        (regs)->storkeys[(pfx)>>11] |= (0x04 | 0x02);
>    }
># 1057 "cpu.c"
>    store_fw_noswap((psa->ioid), __bswap_32 ((ioid)));
>
>
>    store_fw_noswap((psa->ioparm), __bswap_32 ((ioparm)));
>
>
>
>    store_fw_noswap((psa->iointid), __bswap_32 ((iointid)));
>
>
>
>    if (( __builtin_expect(((regs)->tracing),0) && (( sysblk.inststep && ( (sysblk.stepaddr[0] == 0 && sysblk.stepaddr[1] == 0) || (sysblk.stepaddr[0] <= sysblk.stepaddr[1] && ((U64)(((((regs))))->aiv.D + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.D)) >= sysblk.stepaddr[0] && ((U64)(((((regs))))->aiv.D + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.D)) <= sysblk.stepaddr[1] ) || (sysblk.stepaddr[0] > sysblk.stepaddr[1] && ((U64)(((((regs))))->aiv.D + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.D)) >= sysblk.stepaddr[1] && ((U64)(((((regs))))->aiv.D + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.D)) <= sysblk.stepaddr[0] ) ) ) || ( sysblk.insttrace && ( (sysblk.traceaddr[0] == 0 && sysblk.traceaddr[1] == 0) || (sysblk.traceaddr[0] <= sysblk.traceaddr[1] && ((U64)(((((regs))))->aiv.D + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.D)) >= sysblk.traceaddr[0] && ((U64)(((((regs))))->aiv.D + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.D)) <= sysblk.traceaddr[1] ) || (sysblk.traceaddr[0] > sysblk.traceaddr[1] && ((U64)(((((regs))))->aiv.D + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.D)) >= sysblk.traceaddr[1] && ((U64)(((((regs))))->aiv.D + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.D)) <= sysblk.traceaddr[0] ) ) )) ))
>
>
>
>
>        logmsg (("HHCCP046I I/O interrupt code=%8.8X parm=%8.8X id=%8.8X\n"),
>          ioid, ioparm, iointid);
>
>
>
>
>    if(icode == (-1))
>
>    {
>
>        z900_store_psw ( regs, psa->iopold );
>
>
>        rc = z900_load_psw ( regs, psa->iopnew );
>
>        if ( rc )
>        {
>            do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1090"); } while (0);
>            regs->program_interrupt (regs, rc);
>        }
>    }
>
>    do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1095"); } while (0);
>
>    longjmp(regs->progjmp, icode);
>
>}
>
>
>
>
>
>static void z900_perform_mck_interrupt (REGS *regs)
>{
>int rc;
>PSA_900 *psa;
>U64 mcic;
>U32 xdmg;
>U64 fsta;
>
>
>    rc = z900_present_mck_interrupt (regs, &mcic, &xdmg, &fsta);
>
>
>    if (rc == 0) return;
>
>
>    (regs)->storkeys[(regs->px.F.L.F)>>11] |= (0x04 | 0x02);
>
>
>    psa = (void*)(regs->mainstor + regs->px.F.L.F);
>
>
>    z900_store_status (regs, regs->px.F.L.F);
># 1135 "cpu.c"
>    store_dw_i686_noswap((psa->mckint),__bswap_64 ((mcic)));
>
>
>    if (( __builtin_expect(((regs)->tracing),0) && (( sysblk.inststep && ( (sysblk.stepaddr[0] == 0 && sysblk.stepaddr[1] == 0) || (sysblk.stepaddr[0] <= sysblk.stepaddr[1] && ((U64)(((((regs))))->aiv.D + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.D)) >= sysblk.stepaddr[0] && ((U64)(((((regs))))->aiv.D + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.D)) <= sysblk.stepaddr[1] ) || (sysblk.stepaddr[0] > sysblk.stepaddr[1] && ((U64)(((((regs))))->aiv.D + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.D)) >= sysblk.stepaddr[1] && ((U64)(((((regs))))->aiv.D + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.D)) <= sysblk.stepaddr[0] ) ) ) || ( sysblk.insttrace && ( (sysblk.traceaddr[0] == 0 && sysblk.traceaddr[1] == 0) || (sysblk.traceaddr[0] <= sysblk.traceaddr[1] && ((U64)(((((regs))))->aiv.D + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.D)) >= sysblk.traceaddr[0] && ((U64)(((((regs))))->aiv.D + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.D)) <= sysblk.traceaddr[1] ) || (sysblk.traceaddr[0] > sysblk.traceaddr[1] && ((U64)(((((regs))))->aiv.D + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.D)) >= sysblk.traceaddr[1] && ((U64)(((((regs))))->aiv.D + ((intptr_t)((((regs))))->ip - (intptr_t)((((regs))))->aip) + ((-((0))))) & (((((regs))))->psw.amask.D)) <= sysblk.traceaddr[0] ) ) )) ))
>        logmsg (("HHCCP022I Machine Check code=%16.16" "ll" "u\n"),
>                  (long long)mcic);
>
>
>    store_fw_noswap((psa->xdmgcode), __bswap_32 ((xdmg)));
>
>
>
>    store_dw_i686_noswap((psa->mcstorad),__bswap_64 ((fsta)));
>
>
>
>
>
>
>    z900_store_psw ( regs, psa->mckold );
>
>
>    rc = z900_load_psw ( regs, psa->mcknew );
>
>    do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1159"); } while (0);
>
>    if ( rc )
>        regs->program_interrupt (regs, rc);
>
>    longjmp (regs->progjmp, (-11));
>}
># 1411 "cpu.c"
>void (__attribute__ (( regparm(1) )) z900_process_interrupt)(REGS *regs)
>{
>
>    if( ( (regs)->ints_state & (regs)->ints_mask & ( ( 1 << (23) ) | ( 1 << (22) ) | ( 1 << (21) ) | ( 1 << (20) ) | ( 1 << (19) ) | ( 1 << (16) ) ) ) )
>        regs->program_interrupt (regs, 0x0080);
>
>
>    do { REGS *_regs = (regs); if ((_regs)) (_regs)->hostregs->intwait = 1; ptt_pthread_mutex_lock((&sysblk.intlock),"cpu.c" ":" "1418"); if ((_regs)) { while (sysblk.syncing) { sysblk.sync_mask &= ~(_regs)->hostregs->cpubit; if (!sysblk.sync_mask) ptt_pthread_cond_signal((&sysblk.sync_cond),"cpu.c" ":" "1418"); ptt_pthread_cond_wait((&sysblk.sync_bc_cond),(&sysblk.intlock),"cpu.c" ":" "1418"); } (_regs)->hostregs->intwait = 0; sysblk.intowner = (_regs)->hostregs->cpuad; } else sysblk.intowner = 0xFFFE; } while (0);
>    do { (regs)->ints_state &= ~( 1 << (31) ); } while (0);
>    regs->tracing = (sysblk.inststep || sysblk.insttrace);
>
>
>    do { if ((regs)->aie) { (regs)->psw.ia.D = ((U64)((((regs)))->aiv.D + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((0))) & ((((regs)))->psw.amask.D)); (regs)->aie = ((void *)0); } } while (0);
>
>
>    if (__builtin_expect((regs->invalidate),0))
>        z900_invalidate_tlbe(regs, regs->invalidate_main);
>
>
>    if (__builtin_expect((regs->cpustate == 1),1))
>    {
>
>        if ( ( (regs)->ints_state & (regs)->ints_mask & ( ( 1 << (28) ) | ( 1 << (27) ) | ( 1 << (26) ) | ( 1 << (25) ) | ( 1 << (24) ) ) ) )
>        {
>            do { } while (0);
>            do { } while (0);
>            z900_perform_mck_interrupt (regs);
>        }
>
>
>        if ( ( (regs)->ints_state & (regs)->ints_mask & ( ( 1 << (15) ) | ( 1 << (14) ) | ( 1 << (13) ) | ( 1 << (12) ) | ( 1 << (11) ) | ( 1 << (10) ) | ( 1 << (9) ) | ( 1 << (8) ) | ( 1 << (7) ) | ( 1 << (6) ) | ( 1 << (5) ) | ( 1 << (4) ) ) ) )
>        {
>            do { } while (0);
>            do { } while (0);
>            z900_perform_external_interrupt (regs);
>        }
>
>
>        if (( sysblk.ints_state & ( 1 << (30) ) ))
>        {
>            if ( ( (regs)->ints_state & (regs)->ints_mask & ( ( 1 << (30) ) ) ) )
>            {
>                do { } while (0);
>                do { } while (0);
>                z900_perform_io_interrupt (regs);
>            }
>            else
>                do { int i; CPU_BITMAP mask = (sysblk.waiting_mask); for (i = 0; mask; i++) { if (mask & 1) { ptt_pthread_cond_signal((&sysblk.regs[i]->intcond),"cpu.c" ":" "1458"); break; } mask >>= 1; } } while (0);
>        }
>    }
>
>
>    if (__builtin_expect((regs->cpustate == 2),0))
>    {
>
>        regs->opinterv = 0;
>        regs->cpustate = 3;
>
>
>        if (!regs->configured)
>            longjmp(regs->exitjmp, (-1));
>
>
>        if (regs->sigpireset)
>        {
>            do { } while (0);
>            do { } while (0);
>            z900_initial_cpu_reset (regs);
>            do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1479"); } while (0);
>            longjmp(regs->progjmp, (-1));
>        }
>
>
>        if (regs->sigpreset)
>        {
>            do { } while (0);
>            do { } while (0);
>            z900_cpu_reset (regs);
>            do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1489"); } while (0);
>            longjmp(regs->progjmp, (-1));
>        }
>
>
>        if (( (regs)->ints_state & ( 1 << (3) ) ))
>        {
>            do { (regs)->ints_state &= ~( 1 << (3) ); } while (0);
>            z900_store_status (regs, 0);
>            logmsg (("HHCCP010I CPU%4.4X store status completed.\n"),
>                    regs->cpuad);
>
>
>
>
>
>
>
>        }
>    }
>
>
>    if ( ( (regs)->ints_state & ( 1 << (1) ) ) )
>    {
>        do { } while (0);
>        do { } while (0);
>        do { (regs)->ints_state &= ~( 1 << (1) ); } while (0);
>        z900_restart_interrupt (regs);
>    }
>
>
>    if (__builtin_expect((regs->cpustate == 3),0))
>    {
>        S64 saved_timer = cpu_timer(regs);
>        regs->ints_state = ( 1 << (0) );
>        sysblk.started_mask ^= regs->cpubit;
>        sysblk.intowner = 0xFFFF;
>
>
>        ptt_pthread_cond_wait((&regs->intcond),(&sysblk.intlock),"cpu.c" ":" "1528");
>
>
>        while (sysblk.syncing)
>            ptt_pthread_cond_wait((&sysblk.sync_bc_cond),(&sysblk.intlock),"cpu.c" ":" "1532");
>
>        sysblk.intowner = regs->cpuad;
>        sysblk.started_mask |= regs->cpubit;
>        regs->ints_state |= sysblk.ints_state;
>        set_cpu_timer(regs,saved_timer);
>
>        do { (regs)->ints_state |= ( 1 << (31) ); } while (0);
>
>
>        z900_purge_tlb (regs);
>
>        z900_purge_alb (regs);
>
>
>
>        if(sysblk.arch_mode != regs->arch_mode)
>            longjmp(regs->archjmp,(-1));
>
>        do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1551"); } while (0);
>        longjmp(regs->progjmp, (-1));
>    }
>
>
>    if ((((&regs->psw)->states & ( 1 << (1) )) != 0))
>    {
>
>        regs->waittod = host_tod();
>
>
>
>        if( ( ((regs)->ints_mask & ( ( ( 1 << (28) ) | ( 1 << (27) ) | ( 1 << (26) ) | ( 1 << (25) ) | ( 1 << (24) ) ) | ( ( 1 << (15) ) | ( 1 << (14) ) | ( 1 << (13) ) | ( 1 << (12) ) | ( 1 << (11) ) | ( 1 << (10) ) | ( 1 << (9) ) | ( 1 << (8) ) | ( 1 << (7) ) | ( 1 << (6) ) | ( 1 << (5) ) | ( 1 << (4) ) ) | ( ( 1 << (30) ) ) )) == 0 ) )
>        {
>            logmsg (("HHCCP011I CPU%4.4X: Disabled wait state\n" "          ")
>                                   ,
>                    regs->cpuad);
>            display_psw (regs);
>            regs->cpustate = 2;
>            do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1570"); } while (0);
>            longjmp(regs->progjmp, (-1));
>        }
>
>
>        sysblk.intowner = 0xFFFF;
>        sysblk.waiting_mask |= regs->cpubit;
>
>
>        ptt_pthread_cond_wait((&regs->intcond),(&sysblk.intlock),"cpu.c" ":" "1579");
>
>
>        while (sysblk.syncing)
>            ptt_pthread_cond_wait((&sysblk.sync_bc_cond),(&sysblk.intlock),"cpu.c" ":" "1583");
>
>
>        sysblk.waiting_mask ^= regs->cpubit;
>        sysblk.intowner = regs->cpuad;
>
>
>
>        regs->waittime += host_tod() - regs->waittod;
>        regs->waittod = 0;
>
>        do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1594"); } while (0);
>        longjmp(regs->progjmp, (-1));
>    }
>
>
>    do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1599"); } while (0);
>    return;
>
>}
>
>
>
>
>REGS *z900_run_cpu (int cpu, REGS *oldregs)
>{
>BYTE *ip;
>REGS regs;
>
>    if (oldregs)
>    {
>        memcpy (&regs, oldregs, sizeof(REGS));
>        free (oldregs);
>        regs.hostregs = &regs;
>        if (regs.guestregs)
>            regs.guestregs->hostregs = &regs;
>        sysblk.regs[cpu] = &regs;
>        ptt_pthread_mutex_unlock((&sysblk.cpulock[cpu]),"cpu.c" ":" "1620");
>        logmsg (("HHCCP007I CPU%4.4X architecture mode set to %s\n"),
>                cpu, get_arch_mode_string(&regs));
>    }
>    else
>    {
>        memset (&regs, 0, sizeof(REGS));
>
>        if (cpu_init (cpu, &regs, ((void *)0)))
>            return ((void *)0);
>
>        logmsg (("HHCCP003I CPU%4.4X architecture mode %s\n"),
>                cpu, get_arch_mode_string(&regs));
>
>
>
>
>
>
>    }
>
>    regs.program_interrupt = &z900_program_interrupt;
>
>    regs.trace_br = (func)&z900_trace_br;
>
>
>    regs.tracing = (sysblk.inststep || sysblk.insttrace);
>    regs.ints_state |= sysblk.ints_state;
>
>
>    if (_setjmp (regs.exitjmp))
>        return cpu_uninit(cpu, &regs);
>
>
>    _setjmp (regs.archjmp);
>
>
>    if(sysblk.arch_mode != regs.arch_mode)
>    {
>        do { if (pttclass & (0x0100)) ptt_pthread_trace(0x0100,"*SETARCH",(void *)(uintptr_t)(regs.arch_mode),(void *)(uintptr_t)(sysblk.arch_mode),"cpu.c" ":" "1659",(int)(cpu)); } while(0);
>        regs.arch_mode = sysblk.arch_mode;
>        oldregs = malloc (sizeof(REGS));
>        if (oldregs)
>        {
>            memcpy(oldregs, &regs, sizeof(REGS));
>            ptt_pthread_mutex_lock((&sysblk.cpulock[cpu]),"cpu.c" ":" "1665");
>        }
>        else
>        {
>            logmsg (("HHCCP080E CPU%4.4X malloc failed for archjmp regs: %s\n"),
>                    cpu, strerror((*__errno_location ())));
>            cpu_uninit (cpu, &regs);
>        }
>        return oldregs;
>    }
>
>    do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1676"); } while (0);
>
>
>    _setjmp (regs.progjmp);
>
>
>    regs.execflag = 0;
>
>    do {
>        if (( ((&regs))->ints_state & ((&regs))->ints_mask ))
>            z900_process_interrupt(&regs);
>
>        ip = __builtin_expect((( ( !((0)) && ((&regs))->ip < ((&regs))->aie ) || ( ((0)) && (((&regs))->et.D & (0xFFFFFFFFFFFFF000ULL|0x01)) == ((&regs))->aiv.D && ((BYTE *)((uintptr_t)(((&regs)))->aip | (uintptr_t)((((&regs))->et.D) & 0x00000FFF))) < ((&regs))->aie ) )),1) ? ((0) ? ((BYTE *)((uintptr_t)((&regs))->aip | (uintptr_t)(((&regs)->et.D) & 0x00000FFF))) : (&regs)->ip) : z900_instfetch ((&regs), (0));
>        regs.instcount++;
>        do { ; ; (&regs)->z900_opcode_table[ip[0]]((ip), (&regs)); } while(0);
>
>        do {
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->z900_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->z900_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->z900_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->z900_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->z900_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->z900_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>
>            regs.instcount += 12;
>
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->z900_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->z900_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->z900_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->z900_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->z900_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>            if ((&regs)->ip >= (&regs)->aie) break; do { ; ; ((&regs))->z900_opcode_table[(&regs)->ip[0]](((&regs)->ip), ((&regs))); } while(0);
>        } while (!( ((&regs))->ints_state & ((&regs))->ints_mask ));
>    } while (1);
>
>
>    return ((void *)0);
>
>}
>
>
>
>
>void z900_process_trace(REGS *regs)
>{
>int shouldtrace = 0;
>int shouldstep = 0;
>
>
>    if (( sysblk.insttrace && ( (sysblk.traceaddr[0] == 0 && sysblk.traceaddr[1] == 0) || (sysblk.traceaddr[0] <= sysblk.traceaddr[1] && ((U64)((((regs)))->aiv.D + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & ((((regs)))->psw.amask.D)) >= sysblk.traceaddr[0] && ((U64)((((regs)))->aiv.D + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & ((((regs)))->psw.amask.D)) <= sysblk.traceaddr[1] ) || (sysblk.traceaddr[0] > sysblk.traceaddr[1] && ((U64)((((regs)))->aiv.D + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & ((((regs)))->psw.amask.D)) >= sysblk.traceaddr[1] && ((U64)((((regs)))->aiv.D + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & ((((regs)))->psw.amask.D)) <= sysblk.traceaddr[0] ) ) ))
>        shouldtrace = 1;
>
>
>    if (( sysblk.inststep && ( (sysblk.stepaddr[0] == 0 && sysblk.stepaddr[1] == 0) || (sysblk.stepaddr[0] <= sysblk.stepaddr[1] && ((U64)((((regs)))->aiv.D + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & ((((regs)))->psw.amask.D)) >= sysblk.stepaddr[0] && ((U64)((((regs)))->aiv.D + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & ((((regs)))->psw.amask.D)) <= sysblk.stepaddr[1] ) || (sysblk.stepaddr[0] > sysblk.stepaddr[1] && ((U64)((((regs)))->aiv.D + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & ((((regs)))->psw.amask.D)) >= sysblk.stepaddr[1] && ((U64)((((regs)))->aiv.D + ((intptr_t)(((regs)))->ip - (intptr_t)(((regs)))->aip) + ((-(0)))) & ((((regs)))->psw.amask.D)) <= sysblk.stepaddr[0] ) ) ))
>        shouldstep = 1;
>
>
>    if (shouldtrace || shouldstep)
>    {
>        BYTE *ip = regs->ip < regs->aip ? regs->inst : regs->ip;
>        z900_display_inst (regs, ip);
>    }
>
>
>    if (shouldstep)
>    {
>        REGS *hostregs = regs->hostregs;
>        S64 saved_timer[2];
>
>        do { REGS *_regs = (hostregs); if ((_regs)) (_regs)->hostregs->intwait = 1; ptt_pthread_mutex_lock((&sysblk.intlock),"cpu.c" ":" "1745"); if ((_regs)) { while (sysblk.syncing) { sysblk.sync_mask &= ~(_regs)->hostregs->cpubit; if (!sysblk.sync_mask) ptt_pthread_cond_signal((&sysblk.sync_cond),"cpu.c" ":" "1745"); ptt_pthread_cond_wait((&sysblk.sync_bc_cond),(&sysblk.intlock),"cpu.c" ":" "1745"); } (_regs)->hostregs->intwait = 0; sysblk.intowner = (_regs)->hostregs->cpuad; } else sysblk.intowner = 0xFFFE; } while (0);
>
>        hostregs->waittod = host_tod();
>
>
>
>        saved_timer[0] = cpu_timer(regs);
>        saved_timer[1] = cpu_timer(hostregs);
>        hostregs->cpustate = 3;
>        sysblk.started_mask &= ~hostregs->cpubit;
>        hostregs->stepwait = 1;
>        sysblk.intowner = 0xFFFF;
>        while (hostregs->cpustate == 3)
>        {
>            ptt_pthread_cond_wait((&hostregs->intcond),(&sysblk.intlock),"cpu.c" ":" "1759");
>        }
>        sysblk.intowner = hostregs->cpuad;
>        hostregs->stepwait = 0;
>        sysblk.started_mask |= hostregs->cpubit;
>        set_cpu_timer(regs,saved_timer[0]);
>        set_cpu_timer(hostregs,saved_timer[1]);
>
>        hostregs->waittime += host_tod() - hostregs->waittod;
>        hostregs->waittod = 0;
>
>        do { sysblk.intowner = 0xFFFF; ptt_pthread_mutex_unlock((&sysblk.intlock),"cpu.c" ":" "1770"); } while (0);
>    }
>}
># 1791 "cpu.c"
>void z900_set_jump_pointers (REGS *regs, int jump)
>{
>
>
>
>
>    switch (jump) {
>
>
>    case 0xa7:
>jump_a7xx:
> __asm__ (
>        "movzbl 1(%%eax),%%ecx\n\t"
>        "jmp    *%c0(%%edx,%%ecx,4)"
>        : : "i" (__builtin_offsetof (REGS, z900_opcode_a7xx))
>        );
>        return;
>    case 0xb2:
>jump_b2xx:
> __asm__ (
>        "movzbl 1(%%eax),%%ecx\n\t"
>        "jmp    *%c0(%%edx,%%ecx,4)"
>        : : "i" (__builtin_offsetof (REGS, z900_opcode_b2xx))
>        );
>        return;
>    case 0xb9:
>jump_b9xx:
> __asm__ (
>        "movzbl 1(%%eax),%%ecx\n\t"
>        "jmp    *%c0(%%edx,%%ecx,4)"
>        : : "i" (__builtin_offsetof (REGS, z900_opcode_b9xx))
>        );
>        return;
>
>    case 0xc0:
>jump_c0xx:
> __asm__ (
>        "movzbl 1(%%eax),%%ecx\n\t"
>        "jmp    *%c0(%%edx,%%ecx,4)"
>        : : "i" (__builtin_offsetof (REGS, z900_opcode_c0xx))
>        );
>        return;
>    case 0xe3:
>jump_e3xx:
> __asm__ (
>        "movzbl 5(%%eax),%%ecx\n\t"
>        "jmp    *%c0(%%edx,%%ecx,4)"
>        : : "i" (__builtin_offsetof (REGS, z900_opcode_e3xx))
>        );
>        return;
>    case 0xeb:
>
>jump_ebxx:
> __asm__ (
>        "movzbl 5(%%eax),%%ecx\n\t"
>        "jmp    *%c0(%%edx,%%ecx,4)"
>        : : "i" (__builtin_offsetof (REGS, z900_opcode_ebxx))
>        );
>        return;
>
>
>    }
>
>    regs->z900_opcode_table[0xa7] = &&jump_a7xx;
>    regs->z900_opcode_table[0xb2] = &&jump_b2xx;
>    regs->z900_opcode_table[0xb9] = &&jump_b9xx;
>
>    regs->z900_opcode_table[0xc0] = &&jump_c0xx;
>    regs->z900_opcode_table[0xe3] = &&jump_e3xx;
>
>    regs->z900_opcode_table[0xeb] = &&jump_ebxx;
>
>
>
>
>
>
>}
># 1881 "cpu.c" 2
>
>
>
>
>
> void copy_psw (REGS *regs, BYTE *addr)
>{
>REGS cregs;
>int arch_mode;
>
>    memcpy(&cregs, regs, sysblk.regs_copy_len);
>
>
>
>    if (cregs.loadstate)
>    {
>        arch_mode = sysblk.arch_mode;
>    }
>    else
>    {
>        arch_mode = cregs.arch_mode;
>    }
>
>
>    switch(arch_mode) {
>
>        case 0:
>            s370_store_psw(&cregs, addr);
>            break;
>
>
>        case 1:
>            s390_store_psw(&cregs, addr);
>            break;
>
>
>        case 2:
>            z900_store_psw(&cregs, addr);
>            break;
>
>    }
>}
>
>
>
>
>void display_psw (REGS *regs)
>{
>QWORD qword;
>int arch_mode;
>
>    memset(qword, 0, sizeof(qword));
>
>
>
>    if (regs->loadstate)
>    {
>        arch_mode = sysblk.arch_mode;
>    }
>    else
>    {
>        arch_mode = regs->arch_mode;
>    }
>
>    if( arch_mode != 2 )
>    {
>        copy_psw (regs, qword);
>        logmsg (("PSW=%2.2X%2.2X%2.2X%2.2X %2.2X%2.2X%2.2X%2.2X\n"),
>                qword[0], qword[1], qword[2], qword[3],
>                qword[4], qword[5], qword[6], qword[7]);
>    }
>    else
>    {
>        copy_psw (regs, qword);
>        logmsg (("PSW=%2.2X%2.2X%2.2X%2.2X %2.2X%2.2X%2.2X%2.2X " "%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X\n")
>                                                             ,
>                qword[0], qword[1], qword[2], qword[3],
>                qword[4], qword[5], qword[6], qword[7],
>                qword[8], qword[9], qword[10], qword[11],
>                qword[12], qword[13], qword[14], qword[15]);
>    }
>
>}
>
>const char* arch_name[3+2] =
>{
>
>        "S/370",
>
>
>        "ESA/390",
>
>
>        "z/Arch"
>
>};
>
>const char* get_arch_mode_string(REGS* regs)
>{
>    if (!regs) return arch_name[sysblk.arch_mode];
>    else return arch_name[regs->arch_mode];
>}

Actions: View

Attachments on bug 1106758: 905224 | 905225 | 905226 | 934734