# 1 "gunzip_mod.c"
# 1 "<built-in>"
# 1 "<command line>"
# 1 "gunzip_mod.c"
# 13 "gunzip_mod.c"
# 1 "defs.h" 1
# 10 "defs.h"
# 1 "/usr/lib/gcc-lib/m68k-linux/3.3.2/include/stdarg.h" 1 3 4
# 43 "/usr/lib/gcc-lib/m68k-linux/3.3.2/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 105 "/usr/lib/gcc-lib/m68k-linux/3.3.2/include/stdarg.h" 3 4
typedef __gnuc_va_list va_list;
# 11 "defs.h" 2


# 1 "/usr/lib/gcc-lib/m68k-linux/3.3.2/include/linux/a.out.h" 1 3 4
# 17 "/usr/lib/gcc-lib/m68k-linux/3.3.2/include/linux/a.out.h" 3 4
# 1 "/usr/include/asm/a.out.h" 1 3 4



struct exec
{
  unsigned long a_info;
  unsigned a_text;
  unsigned a_data;
  unsigned a_bss;
  unsigned a_syms;
  unsigned a_entry;
  unsigned a_trsize;
  unsigned a_drsize;
};
# 18 "/usr/lib/gcc-lib/m68k-linux/3.3.2/include/linux/a.out.h" 2 3 4




enum machine_type {



  M_OLDSUN2 = 0,




  M_68010 = 1,




  M_68020 = 2,




  M_SPARC = 3,


  M_386 = 100,
  M_MIPS1 = 151,
  M_MIPS2 = 152
};
# 140 "/usr/lib/gcc-lib/m68k-linux/3.3.2/include/linux/a.out.h" 3 4
# 1 "/usr/include/asm/page.h" 1 3 4



# 1 "/usr/include/linux/config.h" 1 3 4



# 1 "/usr/include/linux/autoconf.h" 1 3 4
# 5 "/usr/include/linux/config.h" 2 3 4
# 5 "/usr/include/asm/page.h" 2 3 4
# 141 "/usr/lib/gcc-lib/m68k-linux/3.3.2/include/linux/a.out.h" 2 3 4
# 166 "/usr/lib/gcc-lib/m68k-linux/3.3.2/include/linux/a.out.h" 3 4
struct nlist {
  union {
    char *n_name;
    struct nlist *n_next;
    long n_strx;
  } n_un;
  unsigned char n_type;
  char n_other;
  short n_desc;
  unsigned long n_value;
};
# 244 "/usr/lib/gcc-lib/m68k-linux/3.3.2/include/linux/a.out.h" 3 4
struct relocation_info
{

  int r_address;

  unsigned int r_symbolnum:24;



  unsigned int r_pcrel:1;


  unsigned int r_length:2;






  unsigned int r_extern:1;







  unsigned int r_pad:4;

};
# 14 "defs.h" 2
# 1 "/usr/include/linux/elf.h" 1 3 4



# 1 "/usr/include/linux/types.h" 1 3 4
# 15 "/usr/include/linux/types.h" 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
# 36 "/usr/include/linux/posix_types.h" 3 4
typedef struct {
        unsigned long fds_bits [(1024/(8 * sizeof(unsigned long)))];
} __kernel_fd_set;


typedef void (*__kernel_sighandler_t)(int);


typedef int __kernel_key_t;

# 1 "/usr/include/asm/posix_types.h" 1 3 4
# 10 "/usr/include/asm/posix_types.h" 3 4
typedef unsigned short __kernel_dev_t;
typedef unsigned long __kernel_ino_t;
typedef unsigned short __kernel_mode_t;
typedef unsigned short __kernel_nlink_t;
typedef long __kernel_off_t;
typedef int __kernel_pid_t;
typedef unsigned short __kernel_ipc_pid_t;
typedef unsigned short __kernel_uid_t;
typedef unsigned short __kernel_gid_t;
typedef unsigned int __kernel_size_t;
typedef int __kernel_ssize_t;
typedef int __kernel_ptrdiff_t;
typedef long __kernel_time_t;
typedef long __kernel_suseconds_t;
typedef long __kernel_clock_t;
typedef int __kernel_daddr_t;
typedef char * __kernel_caddr_t;
typedef unsigned short __kernel_uid16_t;
typedef unsigned short __kernel_gid16_t;
typedef unsigned int __kernel_uid32_t;
typedef unsigned int __kernel_gid32_t;

typedef unsigned short __kernel_old_uid_t;
typedef unsigned short __kernel_old_gid_t;


typedef long long __kernel_loff_t;


typedef struct {



        int __val[2];

} __kernel_fsid_t;
# 47 "/usr/include/linux/posix_types.h" 2 3 4
# 16 "/usr/include/linux/types.h" 2 3 4
# 1 "/usr/include/asm/types.h" 1 3 4
# 12 "/usr/include/asm/types.h" 3 4
typedef unsigned short umode_t;






typedef __signed__ char __s8;
typedef unsigned char __u8;

typedef __signed__ short __s16;
typedef unsigned short __u16;

typedef __signed__ int __s32;
typedef unsigned int __u32;


typedef __signed__ long long __s64;
typedef unsigned long long __u64;
# 17 "/usr/include/linux/types.h" 2 3 4



typedef __kernel_fd_set fd_set;
typedef __kernel_dev_t dev_t;
typedef __kernel_ino_t ino_t;
typedef __kernel_mode_t mode_t;
typedef __kernel_nlink_t nlink_t;
typedef __kernel_off_t off_t;
typedef __kernel_pid_t pid_t;
typedef __kernel_daddr_t daddr_t;
typedef __kernel_key_t key_t;
typedef __kernel_suseconds_t suseconds_t;
# 47 "/usr/include/linux/types.h" 3 4
typedef __kernel_uid_t uid_t;
typedef __kernel_gid_t gid_t;



typedef __kernel_loff_t loff_t;
# 61 "/usr/include/linux/types.h" 3 4
typedef __kernel_size_t size_t;




typedef __kernel_ssize_t ssize_t;




typedef __kernel_ptrdiff_t ptrdiff_t;




typedef __kernel_time_t time_t;




typedef __kernel_clock_t clock_t;




typedef __kernel_caddr_t caddr_t;



typedef unsigned char u_char;
typedef unsigned short u_short;
typedef unsigned int u_int;
typedef unsigned long u_long;


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




typedef __u8 u_int8_t;
typedef __s8 int8_t;
typedef __u16 u_int16_t;
typedef __s16 int16_t;
typedef __u32 u_int32_t;
typedef __s32 int32_t;



typedef __u8 uint8_t;
typedef __u16 uint16_t;
typedef __u32 uint32_t;


typedef __u64 uint64_t;
typedef __u64 u_int64_t;
typedef __s64 int64_t;
# 130 "/usr/include/linux/types.h" 3 4
struct ustat {
        __kernel_daddr_t f_tfree;
        __kernel_ino_t f_tinode;
        char f_fname[6];
        char f_fpack[6];
};
# 5 "/usr/include/linux/elf.h" 2 3 4
# 1 "/usr/include/asm/elf.h" 1 3 4
# 9 "/usr/include/asm/elf.h" 3 4
# 1 "/usr/include/asm/ptrace.h" 1 3 4
# 29 "/usr/include/asm/ptrace.h" 3 4
struct pt_regs {
  long d1;
  long d2;
  long d3;
  long d4;
  long d5;
  long a0;
  long a1;
  long a2;
  long d0;
  long orig_d0;
  long stkadj;
  unsigned short sr;
  unsigned long pc;
  unsigned format : 4;
  unsigned vector : 12;
};





struct switch_stack {
        unsigned long d6;
        unsigned long d7;
        unsigned long a3;
        unsigned long a4;
        unsigned long a5;
        unsigned long a6;
        unsigned long retpc;
};
# 10 "/usr/include/asm/elf.h" 2 3 4
# 1 "/usr/include/asm/user.h" 1 3 4
# 33 "/usr/include/asm/user.h" 3 4
struct user_m68kfp_struct {
        unsigned long fpregs[8*3];
        unsigned long fpcntl[3];
};




struct user_regs_struct {
        long d1,d2,d3,d4,d5,d6,d7;
        long a0,a1,a2,a3,a4,a5,a6;
        long d0;
        long usp;
        long orig_d0;
        short stkadj;
        short sr;
        long pc;
        short fmtvec;
        short __fill;
};





struct user{


  struct user_regs_struct regs;

  int u_fpvalid;

  struct user_m68kfp_struct m68kfp;

  unsigned long int u_tsize;
  unsigned long int u_dsize;
  unsigned long int u_ssize;
  unsigned long start_code;
  unsigned long start_stack;



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


  struct user_m68kfp_struct* u_fpstate;
  unsigned long magic;
  char u_comm[32];
};
# 11 "/usr/include/asm/elf.h" 2 3 4

typedef unsigned long elf_greg_t;


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

typedef struct user_m68kfp_struct elf_fpregset_t;
# 6 "/usr/include/linux/elf.h" 2 3 4


typedef __u32 Elf32_Addr;
typedef __u16 Elf32_Half;
typedef __u32 Elf32_Off;
typedef __s32 Elf32_Sword;
typedef __u32 Elf32_Word;


typedef __u64 Elf64_Addr;
typedef __u16 Elf64_Half;
typedef __s16 Elf64_SHalf;
typedef __u64 Elf64_Off;
typedef __s32 Elf64_Sword;
typedef __u32 Elf64_Word;
typedef __u64 Elf64_Xword;
typedef __s64 Elf64_Sxword;
# 177 "/usr/include/linux/elf.h" 3 4
typedef struct dynamic{
  Elf32_Sword d_tag;
  union{
    Elf32_Sword d_val;
    Elf32_Addr d_ptr;
  } d_un;
} Elf32_Dyn;

typedef struct {
  Elf64_Sxword d_tag;
  union {
    Elf64_Xword d_val;
    Elf64_Addr d_ptr;
  } d_un;
} Elf64_Dyn;
# 373 "/usr/include/linux/elf.h" 3 4
typedef struct elf32_rel {
  Elf32_Addr r_offset;
  Elf32_Word r_info;
} Elf32_Rel;

typedef struct elf64_rel {
  Elf64_Addr r_offset;
  Elf64_Xword r_info;
} Elf64_Rel;

typedef struct elf32_rela{
  Elf32_Addr r_offset;
  Elf32_Word r_info;
  Elf32_Sword r_addend;
} Elf32_Rela;

typedef struct elf64_rela {
  Elf64_Addr r_offset;
  Elf64_Xword r_info;
  Elf64_Sxword r_addend;
} Elf64_Rela;

typedef struct elf32_sym{
  Elf32_Word st_name;
  Elf32_Addr st_value;
  Elf32_Word st_size;
  unsigned char st_info;
  unsigned char st_other;
  Elf32_Half st_shndx;
} Elf32_Sym;

typedef struct elf64_sym {
  Elf64_Word st_name;
  unsigned char st_info;
  unsigned char st_other;
  Elf64_Half st_shndx;
  Elf64_Addr st_value;
  Elf64_Xword st_size;
} Elf64_Sym;




typedef struct elf32_hdr{
  unsigned char e_ident[16];
  Elf32_Half e_type;
  Elf32_Half e_machine;
  Elf32_Word e_version;
  Elf32_Addr e_entry;
  Elf32_Off e_phoff;
  Elf32_Off e_shoff;
  Elf32_Word e_flags;
  Elf32_Half e_ehsize;
  Elf32_Half e_phentsize;
  Elf32_Half e_phnum;
  Elf32_Half e_shentsize;
  Elf32_Half e_shnum;
  Elf32_Half e_shstrndx;
} Elf32_Ehdr;

typedef struct elf64_hdr {
  unsigned char e_ident[16];
  Elf64_Half e_type;
  Elf64_Half e_machine;
  Elf64_Word e_version;
  Elf64_Addr e_entry;
  Elf64_Off e_phoff;
  Elf64_Off e_shoff;
  Elf64_Word e_flags;
  Elf64_Half e_ehsize;
  Elf64_Half e_phentsize;
  Elf64_Half e_phnum;
  Elf64_Half e_shentsize;
  Elf64_Half e_shnum;
  Elf64_Half e_shstrndx;
} Elf64_Ehdr;







typedef struct elf32_phdr{
  Elf32_Word p_type;
  Elf32_Off p_offset;
  Elf32_Addr p_vaddr;
  Elf32_Addr p_paddr;
  Elf32_Word p_filesz;
  Elf32_Word p_memsz;
  Elf32_Word p_flags;
  Elf32_Word p_align;
} Elf32_Phdr;

typedef struct elf64_phdr {
  Elf64_Word p_type;
  Elf64_Word p_flags;
  Elf64_Off p_offset;
  Elf64_Addr p_vaddr;
  Elf64_Addr p_paddr;
  Elf64_Xword p_filesz;
  Elf64_Xword p_memsz;
  Elf64_Xword p_align;
} Elf64_Phdr;
# 518 "/usr/include/linux/elf.h" 3 4
typedef struct {
  Elf32_Word sh_name;
  Elf32_Word sh_type;
  Elf32_Word sh_flags;
  Elf32_Addr sh_addr;
  Elf32_Off sh_offset;
  Elf32_Word sh_size;
  Elf32_Word sh_link;
  Elf32_Word sh_info;
  Elf32_Word sh_addralign;
  Elf32_Word sh_entsize;
} Elf32_Shdr;

typedef struct elf64_shdr {
  Elf64_Word sh_name;
  Elf64_Word sh_type;
  Elf64_Xword sh_flags;
  Elf64_Addr sh_addr;
  Elf64_Off sh_offset;
  Elf64_Xword sh_size;
  Elf64_Word sh_link;
  Elf64_Word sh_info;
  Elf64_Xword sh_addralign;
  Elf64_Xword sh_entsize;
} Elf64_Shdr;
# 581 "/usr/include/linux/elf.h" 3 4
typedef struct elf32_note {
  Elf32_Word n_namesz;
  Elf32_Word n_descsz;
  Elf32_Word n_type;
} Elf32_Nhdr;


typedef struct elf64_note {
  Elf64_Word n_namesz;
  Elf64_Word n_descsz;
  Elf64_Word n_type;
} Elf64_Nhdr;



extern Elf32_Dyn _DYNAMIC [];
# 15 "defs.h" 2
# 1 "/usr/include/linux/linkage.h" 1 3 4
# 16 "defs.h" 2


# 1 "version.h" 1
# 19 "defs.h" 2
# 1 "bootinfo.h" 1
# 27 "bootinfo.h"
struct bi_record {
    unsigned short tag;
    unsigned short size;
    unsigned long data[0];
};
# 90 "bootinfo.h"
struct bootversion {
    unsigned short branch;
    unsigned long magic;
    struct {
                unsigned long machtype;
                unsigned long version;
    } machversions[0];
};
# 170 "bootinfo.h"
struct mem_info {
        unsigned long addr;
        unsigned long size;
};
# 190 "bootinfo.h"
struct compat_mem_info {
    unsigned long addr;
    unsigned long size;
};
# 219 "bootinfo.h"
struct compat_bootinfo {
    unsigned long machtype;
    unsigned long cputype;
    struct compat_mem_info memory[4];
    int num_memory;
    unsigned long ramdisk_size;
    unsigned long ramdisk_addr;
    char command_line[(256)];
};
# 20 "defs.h" 2
# 1 "stream.h" 1
# 16 "stream.h"
typedef struct _module {

    char *name;
    long maxbuf;


    int (*open)( void *data, long size);
    long (*fillbuf)( void *buf );

    int (*skip)( long cnt );

    int (*close)( void );

    char *buf;
    char *bufp;
    long buf_cnt;
    long fpos;
    int eof;

    struct _module *down, *up;
} MODULE;






extern MODULE *currmod;



void stream_init( void );
void stream_push( MODULE *mod );
int sopen( void *data, long size);
long sread( void *buf, long cnt );
int sseek( long offset, int whence );
int sclose( void );
# 21 "defs.h" 2
# 52 "defs.h"
typedef enum {
        IP_CLIENT,
        IP_SERVER,
        IP_GATEWAY,
        IP_BROADCAST,
        IP_NETMASK

} IPTYPE;






extern char _tail;




typedef struct boot_tag {
        struct boot_tag *next;
        char *label;
        char *alias;
        char *description;
        char *kernel;
        char *ramdisk;
        char *cmdline;
        char *append;
        char *root;
        char *console;
        char read_only;
        char restricted;
        char calldbg;
        unsigned long memsize;

} BOOT;



typedef struct crate_tag {
        unsigned long timeout;
        unsigned long delay;
        int prompt;
        char *display;
        char *kernel;
        char *ramdisk;
        char *cmdline;
        char *append;
        char *root;
        char *console;
        char read_only;
        char restricted;
        char calldbg;
        unsigned long memsize;
        BOOT *boot_dflt;
        BOOT *boot_list;

} CRATE;





struct internal_bootinfo
{
        unsigned long machtype;
        unsigned long cputype;
        unsigned long fputype;
        unsigned long mmutype;
        int num_memory;
        struct mem_info memory[(4)];
        struct mem_info ramdisk;
        char command_line[(256)];
};





typedef struct {
        unsigned long d[8];
        void *a[7];

} CALLREGS;





extern MODULE memory_mod;
extern MODULE gunzip_mod;







extern void (*startcode_entry)(void);
extern char *config_data;
extern char *config_data_end;
extern char input_buffer[256];
extern unsigned long detected_mem_size;
extern int debug_mode;
extern int cpu_type;
extern int fpu_type;
extern CALLREGS callregs;
extern struct internal_bootinfo bi;


extern struct compat_bootinfo compat_bootinfo;



extern unsigned long bi_size;
extern union {
                        struct bi_record record;
                        unsigned char fake[(4096)];
                } bi_union;




int check_bootinfo_version (const char *memptr);
int add_bi_record (unsigned short tag,unsigned short size,const void *data);
int add_bi_string (unsigned short tag,const unsigned char *s);
int create_bootinfo (void);
int create_compat_bootinfo (void);
void start_kernel (unsigned long kernel_dest_addr,char *kernel_load_addr,unsigned long kernel_mem_size,unsigned long ramdisk_dest_addr,char *ramdisk_load_addr,unsigned long ramdisk_mem_size,int calldbg);
char * load_kernel (char *file_name,unsigned long mem_start,unsigned long *kernel_size,unsigned long bootinfo_size);
void boot_linux (BOOT *boot,const char *more,int autoboot);


void loader_init (CALLREGS *regs);
void put_char (const int c);
unsigned long get_time (void);
int get_char (unsigned long timeout);
const char * get_ip (IPTYPE type);
const char * config_filename (void);
int tftp_read (const char *filename,unsigned long count,void *buffer);
unsigned long get_compat_booti_version (void);
unsigned long get_booti_version (void);
unsigned long get_compat_machtype (void);
unsigned long get_machtype (void);
void print_model (void);
unsigned long get_vme_type (void);
int add_vme_bootinfo (void);


int keyword (const char *name);
char * goto_line (int line);
int print_display_section (const char *label);
int find_boot_section (const char *label);
int find_crate_section (const char *search);
int get_number (const char *p,unsigned long *result);
int get_bool (const char *text);
void config_error (int line,char *data);
int bool_config_error (int line,char *data,int willuse);
unsigned long number_config_error (int line,char *data,unsigned long willuse);
void ignore_option (int line,char *data);
void duplicate_option (int line,char *data);
BOOT * find_boot_config (BOOT *boot,char *bootname);
BOOT * add_boot (CRATE *crate,BOOT *boot);
void dump_crate (CRATE *crate);
BOOT * parse_boot (int line,CRATE *crate);
void build_boot_from_defaults (CRATE *crate);
void build_boot_list (CRATE *crate);
void parse_globals (CRATE *crate);
void parse_config (CRATE *crate);


int read_line (unsigned long timeout);
void list_records (CRATE *crate);
BOOT * get_boot_record (CRATE *crate,const char **more);
void start_loader (void);
void Main (CALLREGS *regs);


void mem_clear (void *mem,unsigned long count);
void mem_move (void *dest,const void *srce,unsigned long count);
int mem_cmp (void *mem1,void *mem2,unsigned long count);
void malloc_init (void *heap_base,unsigned long heap_size);
int free (void *memaddr);
void * do_malloc (unsigned long size,int high);
void * malloc (unsigned long size);
void * malloc_low (unsigned long size);
unsigned long maxfree (void);
void * move_up (void *memaddr,unsigned long memsize);
void * realloc (void *memaddr,unsigned long size);
unsigned long disable_icache (void);
unsigned long enable_icache (void);
void invalidate_icache (void);
void erase (int n);
int strlen (const char *s);
char * strcpy (char *d,const char *s);
void strcat (char *d,const char *s);
void strcatn (char *d,const char *s,unsigned long n);
void strncpy (char *d,const char *s,unsigned long n);
int vsoutput (void (*output)(const int),const char *fmt,va_list va);
int sprintf (char *buff,const char *fmt,...);
int printf (const char *fmt,...);
int put_estr (const char *str);
int put_str (const char *str);
void panic (const char *fmt,...);
void * xmalloc (int size);
char * skip_white (const char *p);
void trim_white (char *p);
char * despace (char *str);
int equal_strings (const char *s1,const char *s2);
char * extract (char *p1,char *p2,int len,int delim);
int prescan (char *data,int size);
int check_arch (char *text);
char * mkinet (unsigned long ip);
unsigned atou (const char **strp);
int compare_ip (const char *ipstr,const char *pattern);
void substip (char *dest,const char *srce,int maxlen);
char * tftp (char *filename,unsigned long *filesize);
int get_cpu_type (void);
int get_fpu_type (void);
int ram_probe (unsigned long where);


void stream_init(void);
void stream_push(MODULE *mod);
int sopen(void *data,long size);
long sread(void *buf,long cnt);
int sseek(long offset,int whence);
int sclose(void);
# 14 "gunzip_mod.c" 2
# 23 "gunzip_mod.c"
typedef unsigned char uch;
typedef unsigned short ush;
typedef unsigned long ulg;
# 39 "gunzip_mod.c"
static int gunzip_open( void *data, long count );
static long gunzip_fillbuf( void *buf );
static int gunzip_close( void );
static int call_gunzip( void );
static void gzip_mark( void **ptr );
static void gzip_release( void **ptr );
static int fill_inbuf( void );
static void flush_window( void );
static void error( char *x );



MODULE gunzip_mod = {
        "gunzip",
        (32*1024),
        gunzip_open,
        gunzip_fillbuf,
        ((void *)0),
        gunzip_close,
        ((void *)0), ((void *)0), 0, 0, 0, ((void *)0), ((void *)0)
};


static char *gunzip_stack;

static long gunzip_sp, gunzip_jumpback, main_sp, main_fp;




static uch *inbuf;
static uch *window;
static uch *previous_window;

static unsigned insize = 0;
static unsigned inptr = 0;
static unsigned outcnt = 0;
static int exit_code = 0;
static long bytes_out = 0;
static int made_crc_table = 0;
# 96 "gunzip_mod.c"
# 1 "inflate.c" 1
# 124 "inflate.c"
struct huft {
  uch e;
  uch b;
  union {
    ush n;
    struct huft *t;
  } v;
};



static int huft_build (unsigned *, unsigned, unsigned, ush *, ush *, struct huft **, int *);

static int huft_free (struct huft *);
static int inflate_codes (struct huft *, struct huft *, int, int);
static int inflate_stored (void);
static int inflate_fixed (void);
static int inflate_dynamic (void);
static int inflate_block (int *);
static int inflate (void);
# 159 "inflate.c"
static unsigned border[] = {
        16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
static ush cplens[] = {
        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
        35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};

static ush cplext[] = {
        0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
        3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99};
static ush cpdist[] = {
        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
        257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
        8193, 12289, 16385, 24577};
static ush cpdext[] = {
        0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
        7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
        12, 12, 13, 13};
# 209 "inflate.c"
static ulg bb;
static unsigned bk;

static ush mask_bits[] = {
    0x0000,
    0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
    0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
};
# 256 "inflate.c"
static int lbits = 9;
static int dbits = 6;







static unsigned hufts;


static int huft_build(b, n, s, d, e, t, m)
unsigned *b;
unsigned n;
unsigned s;
ush *d;
ush *e;
struct huft **t;
int *m;





{
  unsigned a;
  unsigned c[16 +1];
  unsigned f;
  int g;
  int h;
  register unsigned i;
  register unsigned j;
  register int k;
  int l;
  register unsigned *p;
  register struct huft *q;
  struct huft r;
  struct huft *u[16];
  unsigned v[288];
  register int w;
  unsigned x[16 +1];
  unsigned *xp;
  int y;
  unsigned z;

;


  mem_clear ((c), (sizeof(c)));
  p = b; i = n;
  do {
    ;

    c[*p]++;
    p++;
  } while (--i);
  if (c[0] == n)
  {
    *t = (struct huft *)((void *)0);
    *m = 0;
    return 0;
  }

;


  l = *m;
  for (j = 1; j <= 16; j++)
    if (c[j])
      break;
  k = j;
  if ((unsigned)l < j)
    l = j;
  for (i = 16; i; i--)
    if (c[i])
      break;
  g = i;
  if ((unsigned)l > i)
    l = i;
  *m = l;

;


  for (y = 1 << j; j < i; j++, y <<= 1)
    if ((y -= c[j]) < 0)
      return 2;
  if ((y -= c[i]) < 0)
    return 2;
  c[i] += y;

;


  x[1] = j = 0;
  p = c + 1; xp = x + 2;
  while (--i) {
    *xp++ = (j += *p++);
  }

;


  p = b; i = 0;
  do {
    if ((j = *p++) != 0)
      v[x[j]++] = i;
  } while (++i < n);

;


  x[0] = i = 0;
  p = v;
  h = -1;
  w = -l;
  u[0] = (struct huft *)((void *)0);
  q = (struct huft *)((void *)0);
  z = 0;
;


  for (; k <= g; k++)
  {
;
    a = c[k];
    while (a--)
    {
;


      while (k > w + l)
      {
;
        h++;
        w += l;


        z = (z = g - w) > (unsigned)l ? l : z;
        if ((f = 1 << (j = k - w)) > a + 1)
        {
;
          f -= a + 1;
          xp = c + k;
          while (++j < z)
          {
            if ((f <<= 1) <= *++xp)
              break;
            f -= *xp;
          }
        }
;
        z = 1 << j;


        if ((q = (struct huft *)malloc((z + 1)*sizeof(struct huft))) ==
            (struct huft *)((void *)0))
        {
          if (h)
            huft_free(u[0]);
          return 3;
        }
;
        hufts += z + 1;
        *t = q + 1;
        *(t = &(q->v.t)) = (struct huft *)((void *)0);
        u[h] = ++q;

;

        if (h)
        {
          x[h] = i;
          r.b = (uch)l;
          r.e = (uch)(16 + j);
          r.v.t = q;
          j = i >> (w - l);
          u[h-1][j] = r;
        }
;
      }
;


      r.b = (uch)(k - w);
      if (p >= v + n)
        r.e = 99;
      else if (*p < s)
      {
        r.e = (uch)(*p < 256 ? 16 : 15);
        r.v.n = (ush)(*p);
        p++;
      }
      else
      {
        r.e = (uch)e[*p - s];
        r.v.n = d[*p++ - s];
      }
;


      f = 1 << (k - w);
      for (j = i >> w; j < z; j += f)
        q[j] = r;


      for (j = 1 << (k - 1); i & j; j >>= 1)
        i ^= j;
      i ^= j;


      while ((i & ((1 << w) - 1)) != x[h])
      {
        h--;
        w -= l;
      }
;
    }
;
  }

;


  return y != 0 && g != 1;
}



static int huft_free(t)
struct huft *t;



{
  register struct huft *p, *q;



  p = t;
  while (p != (struct huft *)((void *)0))
  {
    q = (--p)->v.t;
    free((char*)p);
    p = q;
  }
  return 0;
}


static int inflate_codes(tl, td, bl, bd)
struct huft *tl, *td;
int bl, bd;


{
  register unsigned e;
  unsigned n, d;
  unsigned w;
  struct huft *t;
  unsigned ml, md;
  register ulg b;
  register unsigned k;



  b = bb;
  k = bk;
  w = outcnt;


  ml = mask_bits[bl];
  md = mask_bits[bd];
  for (;;)
  {
    {while(k<((unsigned)bl)){b|=((ulg)(uch)(inptr < insize ? inbuf[inptr++] : fill_inbuf()))<<k;k+=8;}}
    if ((e = (t = tl + ((unsigned)b & ml))->e) > 16)
      do {
        if (e == 99)
          return 1;
        {b>>=(t->b);k-=(t->b);}
        e -= 16;
        {while(k<(e)){b|=((ulg)(uch)(inptr < insize ? inbuf[inptr++] : fill_inbuf()))<<k;k+=8;}}
      } while ((e = (t = t->v.t + ((unsigned)b & mask_bits[e]))->e) > 16);
    {b>>=(t->b);k-=(t->b);}
    if (e == 16)
    {
      window[w++] = (uch)t->v.n;
      ;
      if (w == (32*1024))
      {
        (outcnt=(w),flush_window());
        w = 0;
      }
    }
    else
    {

      if (e == 15)
        break;


      {while(k<(e)){b|=((ulg)(uch)(inptr < insize ? inbuf[inptr++] : fill_inbuf()))<<k;k+=8;}}
      n = t->v.n + ((unsigned)b & mask_bits[e]);
      {b>>=(e);k-=(e);};


      {while(k<((unsigned)bd)){b|=((ulg)(uch)(inptr < insize ? inbuf[inptr++] : fill_inbuf()))<<k;k+=8;}}
      if ((e = (t = td + ((unsigned)b & md))->e) > 16)
        do {
          if (e == 99)
            return 1;
          {b>>=(t->b);k-=(t->b);}
          e -= 16;
          {while(k<(e)){b|=((ulg)(uch)(inptr < insize ? inbuf[inptr++] : fill_inbuf()))<<k;k+=8;}}
        } while ((e = (t = t->v.t + ((unsigned)b & mask_bits[e]))->e) > 16);
      {b>>=(t->b);k-=(t->b);}
      {while(k<(e)){b|=((ulg)(uch)(inptr < insize ? inbuf[inptr++] : fill_inbuf()))<<k;k+=8;}}
      d = w - t->v.n - ((unsigned)b & mask_bits[e]);
      {b>>=(e);k-=(e);}
      ;


      do {
        n -= (e = (e = (32*1024) - ((d &= (32*1024)-1) > w ? d : w)) > n ? n : e);

        if (w - d >= e)
        {

                  long adjust = (d > w) ? previous_window - window : 0;
          mem_move(window + w, window + d + adjust, e);



          w += e;
          d += e;
        }
        else

          do {
            window[w++] = window[d++];
            ;
          } while (--e);
        if (w == (32*1024))
        {
          (outcnt=(w),flush_window());
          w = 0;
        }
      } while (n);
    }
  }



  outcnt = w;
  bb = b;
  bk = k;


  return 0;
}



static int inflate_stored()

{
  unsigned n;
  unsigned w;
  register ulg b;
  register unsigned k;

;


  b = bb;
  k = bk;
  w = outcnt;



  n = k & 7;
  {b>>=(n);k-=(n);};



  {while(k<(16)){b|=((ulg)(uch)(inptr < insize ? inbuf[inptr++] : fill_inbuf()))<<k;k+=8;}}
  n = ((unsigned)b & 0xffff);
  {b>>=(16);k-=(16);}
  {while(k<(16)){b|=((ulg)(uch)(inptr < insize ? inbuf[inptr++] : fill_inbuf()))<<k;k+=8;}}
  if (n != (unsigned)((~b) & 0xffff))
    return 1;
  {b>>=(16);k-=(16);}



  while (n--)
  {
    {while(k<(8)){b|=((ulg)(uch)(inptr < insize ? inbuf[inptr++] : fill_inbuf()))<<k;k+=8;}}
    window[w++] = (uch)b;
    if (w == (32*1024))
    {
      (outcnt=(w),flush_window());
      w = 0;
    }
    {b>>=(8);k-=(8);}
  }



  outcnt = w;
  bb = b;
  bk = k;

  ;
  return 0;
}



static int inflate_fixed()



{
  int i;
  struct huft *tl;
  struct huft *td;
  int bl;
  int bd;
  unsigned l[288];

;


  for (i = 0; i < 144; i++)
    l[i] = 8;
  for (; i < 256; i++)
    l[i] = 9;
  for (; i < 280; i++)
    l[i] = 7;
  for (; i < 288; i++)
    l[i] = 8;
  bl = 7;
  if ((i = huft_build(l, 288, 257, cplens, cplext, &tl, &bl)) != 0)
    return i;



  for (i = 0; i < 30; i++)
    l[i] = 5;
  bd = 5;
  if ((i = huft_build(l, 30, 0, cpdist, cpdext, &td, &bd)) > 1)
  {
    huft_free(tl);

    ;
    return i;
  }



  if (inflate_codes(tl, td, bl, bd))
    return 1;



  huft_free(tl);
  huft_free(td);
  return 0;
}



static int inflate_dynamic()

{
  int i;
  unsigned j;
  unsigned l;
  unsigned m;
  unsigned n;
  struct huft *tl;
  struct huft *td;
  int bl;
  int bd;
  unsigned nb;
  unsigned nl;
  unsigned nd;



  unsigned ll[286+30];

  register ulg b;
  register unsigned k;

;


  b = bb;
  k = bk;



  {while(k<(5)){b|=((ulg)(uch)(inptr < insize ? inbuf[inptr++] : fill_inbuf()))<<k;k+=8;}}
  nl = 257 + ((unsigned)b & 0x1f);
  {b>>=(5);k-=(5);}
  {while(k<(5)){b|=((ulg)(uch)(inptr < insize ? inbuf[inptr++] : fill_inbuf()))<<k;k+=8;}}
  nd = 1 + ((unsigned)b & 0x1f);
  {b>>=(5);k-=(5);}
  {while(k<(4)){b|=((ulg)(uch)(inptr < insize ? inbuf[inptr++] : fill_inbuf()))<<k;k+=8;}}
  nb = 4 + ((unsigned)b & 0xf);
  {b>>=(4);k-=(4);}



  if (nl > 286 || nd > 30)

    return 1;

;


  for (j = 0; j < nb; j++)
  {
    {while(k<(3)){b|=((ulg)(uch)(inptr < insize ? inbuf[inptr++] : fill_inbuf()))<<k;k+=8;}}
    ll[border[j]] = (unsigned)b & 7;
    {b>>=(3);k-=(3);}
  }
  for (; j < 19; j++)
    ll[border[j]] = 0;

;


  bl = 7;
  if ((i = huft_build(ll, 19, 19, ((void *)0), ((void *)0), &tl, &bl)) != 0)
  {
    if (i == 1)
      huft_free(tl);
    return i;
  }

;


  n = nl + nd;
  m = mask_bits[bl];
  i = l = 0;
  while ((unsigned)i < n)
  {
    {while(k<((unsigned)bl)){b|=((ulg)(uch)(inptr < insize ? inbuf[inptr++] : fill_inbuf()))<<k;k+=8;}}
    j = (td = tl + ((unsigned)b & m))->b;
    {b>>=(j);k-=(j);}
    j = td->v.n;
    if (j < 16)
      ll[i++] = l = j;
    else if (j == 16)
    {
      {while(k<(2)){b|=((ulg)(uch)(inptr < insize ? inbuf[inptr++] : fill_inbuf()))<<k;k+=8;}}
      j = 3 + ((unsigned)b & 3);
      {b>>=(2);k-=(2);}
      if ((unsigned)i + j > n)
        return 1;
      while (j--)
        ll[i++] = l;
    }
    else if (j == 17)
    {
      {while(k<(3)){b|=((ulg)(uch)(inptr < insize ? inbuf[inptr++] : fill_inbuf()))<<k;k+=8;}}
      j = 3 + ((unsigned)b & 7);
      {b>>=(3);k-=(3);}
      if ((unsigned)i + j > n)
        return 1;
      while (j--)
        ll[i++] = 0;
      l = 0;
    }
    else
    {
      {while(k<(7)){b|=((ulg)(uch)(inptr < insize ? inbuf[inptr++] : fill_inbuf()))<<k;k+=8;}}
      j = 11 + ((unsigned)b & 0x7f);
      {b>>=(7);k-=(7);}
      if ((unsigned)i + j > n)
        return 1;
      while (j--)
        ll[i++] = 0;
      l = 0;
    }
  }

;


  huft_free(tl);

;


  bb = b;
  bk = k;

;


  bl = lbits;
  if ((i = huft_build(ll, nl, 257, cplens, cplext, &tl, &bl)) != 0)
  {
;
    if (i == 1) {
      error(" incomplete literal tree\n");
      huft_free(tl);
    }
    return i;
  }
;
  bd = dbits;
  if ((i = huft_build(ll + nl, nd, 0, cpdist, cpdext, &td, &bd)) != 0)
  {
;
    if (i == 1) {
      error(" incomplete distance tree\n");




      huft_free(td);
    }
    huft_free(tl);
    return i;

  }

;


  if (inflate_codes(tl, td, bl, bd))
    return 1;

;


  huft_free(tl);
  huft_free(td);

  ;
  return 0;
}



static int inflate_block(e)
int *e;

{
  unsigned t;
  register ulg b;
  register unsigned k;

  ;


  b = bb;
  k = bk;



  {while(k<(1)){b|=((ulg)(uch)(inptr < insize ? inbuf[inptr++] : fill_inbuf()))<<k;k+=8;}}
  *e = (int)b & 1;
  {b>>=(1);k-=(1);}



  {while(k<(2)){b|=((ulg)(uch)(inptr < insize ? inbuf[inptr++] : fill_inbuf()))<<k;k+=8;}}
  t = (unsigned)b & 3;
  {b>>=(2);k-=(2);}



  bb = b;
  bk = k;


  if (t == 2)
    return inflate_dynamic();
  if (t == 0)
    return inflate_stored();
  if (t == 1)
    return inflate_fixed();

  ;


  return 2;
}



static int inflate()

{
  int e;
  int r;
  unsigned h;
  void *ptr;


  outcnt = 0;
  bk = 0;
  bb = 0;



  h = 0;
  do {
    hufts = 0;
    gzip_mark(&ptr);
    if ((r = inflate_block(&e)) != 0) {
      gzip_release(&ptr);
      return r;
    }
    gzip_release(&ptr);
    if (hufts > h)
      h = hufts;
  } while (!e);




  while (bk >= 8) {
    bk -= 8;
    inptr--;
  }


  (outcnt=(outcnt),flush_window());






  return 0;
}







static ulg crc_32_tab[256];
static ulg crc = (ulg)0xffffffffL;







static void
makecrc(void)
{


  unsigned long c;
  unsigned long e;
  int i;
  int k;


  static int p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};


  e = 0;
  for (i = 0; i < sizeof(p)/sizeof(int); i++)
    e |= 1L << (31 - p[i]);

  crc_32_tab[0] = 0;

  for (i = 1; i < 256; i++)
  {
    c = 0;
    for (k = i | 256; k != 1; k >>= 1)
    {
      c = c & 1 ? (c >> 1) ^ e : c >> 1;
      if (k & 1)
        c ^= e;
    }
    crc_32_tab[i] = c;
  }
}
# 1063 "inflate.c"
static int gunzip(void)
{
    uch flags;
    unsigned char magic[2];
    char method;
    ulg orig_crc = 0;
    ulg orig_len = 0;
    int res;

    magic[0] = (unsigned char)(inptr < insize ? inbuf[inptr++] : fill_inbuf());
    magic[1] = (unsigned char)(inptr < insize ? inbuf[inptr++] : fill_inbuf());
    method = (unsigned char)(inptr < insize ? inbuf[inptr++] : fill_inbuf());

    if (magic[0] != 037 ||
        ((magic[1] != 0213) && (magic[1] != 0236))) {
            error("bad gzip magic numbers");
            return -1;
    }


    if (method != 8) {
            error("internal error, invalid method");
            return -1;
    }

    flags = (uch)(inptr < insize ? inbuf[inptr++] : fill_inbuf());
    if ((flags & 0x20) != 0) {
            error("Input is encrypted\n");
            return -1;
    }
    if ((flags & 0x02) != 0) {
            error("Multi part input\n");
            return -1;
    }
    if ((flags & 0xC0) != 0) {
            error("Input has invalid flags\n");
            return -1;
    }
    (ulg)(inptr < insize ? inbuf[inptr++] : fill_inbuf());
    ((ulg)(inptr < insize ? inbuf[inptr++] : fill_inbuf())) << 8;
    ((ulg)(inptr < insize ? inbuf[inptr++] : fill_inbuf())) << 16;
    ((ulg)(inptr < insize ? inbuf[inptr++] : fill_inbuf())) << 24;

    (void)(inptr < insize ? inbuf[inptr++] : fill_inbuf());
    (void)(inptr < insize ? inbuf[inptr++] : fill_inbuf());

    if ((flags & 0x04) != 0) {
            unsigned len = (unsigned)(inptr < insize ? inbuf[inptr++] : fill_inbuf());
            len |= ((unsigned)(inptr < insize ? inbuf[inptr++] : fill_inbuf()))<<8;
            while (len--) (void)(inptr < insize ? inbuf[inptr++] : fill_inbuf());
    }


    if ((flags & 0x08) != 0) {

            while ((inptr < insize ? inbuf[inptr++] : fill_inbuf()) != 0) ;
    }


    if ((flags & 0x10) != 0) {
            while ((inptr < insize ? inbuf[inptr++] : fill_inbuf()) != 0) ;
    }


    if ((res = inflate())) {
            switch (res) {
            case 0:
                    break;
            case 1:
                    error("invalid compressed format (err=1)");
                    break;
            case 2:
                    error("invalid compressed format (err=2)");
                    break;
            case 3:
                    error("out of memory");
                    break;
            default:
                    error("invalid compressed format (other)");
            }
            return -1;
    }





    orig_crc = (ulg) (inptr < insize ? inbuf[inptr++] : fill_inbuf());
    orig_crc |= (ulg) (inptr < insize ? inbuf[inptr++] : fill_inbuf()) << 8;
    orig_crc |= (ulg) (inptr < insize ? inbuf[inptr++] : fill_inbuf()) << 16;
    orig_crc |= (ulg) (inptr < insize ? inbuf[inptr++] : fill_inbuf()) << 24;

    orig_len = (ulg) (inptr < insize ? inbuf[inptr++] : fill_inbuf());
    orig_len |= (ulg) (inptr < insize ? inbuf[inptr++] : fill_inbuf()) << 8;
    orig_len |= (ulg) (inptr < insize ? inbuf[inptr++] : fill_inbuf()) << 16;
    orig_len |= (ulg) (inptr < insize ? inbuf[inptr++] : fill_inbuf()) << 24;


    if (orig_crc != (crc ^ 0xffffffffL)) {
            error("crc error");
            return -1;
    }
    if (orig_len != bytes_out) {
            error("length error");
            return -1;
    }
    return 0;
}
# 97 "gunzip_mod.c" 2

static int gunzip_open( void *data, long count )
{
        int rv;
        unsigned char buf[2];

        insize = 0;
        inptr = 0;
        outcnt = 0;
        exit_code = 0;
        bytes_out = 0;
        crc = (ulg)0xffffffffL;
        if (!made_crc_table)
        {
                ++made_crc_table;
                makecrc();
        }


        if (sopen( data, count ) < 0)
                return( -1 );


        rv = sread( buf, 2 );
        sseek( 0, 0 );
        if (rv < 2) {
                printf( "File shorter than 2 bytes, can't test for gzip\n" );
                return( -1 );
        }
    if (buf[0] != 037 || (buf[1] != 0213 && buf[1] != 0236))

                return( 1 );

        if (!(gunzip_stack = malloc( (4*1024) ))) {
                printf( "Out of memory for gunzip stack!\n" );
                return( -1 );
        }
        gunzip_sp = 0;

        if (!(inbuf = malloc( (32*1024) ))) {
                printf( "Out of memory for gunzip input buffer!\n" );
                return( -1 );
        }




        return( 0 );
}

static __inline__ unsigned long getsp( void )
{
        ulg ret;
        __asm__ __volatile__
                ( "movl	%%sp,%0" : "=r" (ret) : );
        return( ret );
}

static long gunzip_fillbuf( void *buf )
{
        previous_window = window;
        window = buf;
        return( call_gunzip() );
}

static int gunzip_close( void )
{
        free( gunzip_stack );
        free( inbuf );
        sclose();



        return( 0 );
}

static void gzip_mark( void **ptr )
{
}

static void gzip_release( void **ptr )
{
}
# 195 "gunzip_mod.c"
static int call_gunzip( void )
{
        int rv = 0;


        (void)&main_sp;
        (void)&main_fp;
        (void)&gunzip_jumpback;
        (void)gunzip;

        if (!gunzip_sp) {
                register int asm_rv __asm__ ("d0");


                __asm__ __volatile__ (
                        "movl	%%sp,main_sp\n\t"
                        "movl	%%a6,main_fp\n\t"
                        "movl	%1,%%sp\n\t"
                        "jbsr	gunzip\n\t"
                "_return_from_flush:\n\t"
                        "movl	main_sp,%%sp\n\t"
                        "movl	main_fp,%%a6"
                        : "=d" (asm_rv)
                        : "g" (gunzip_stack+(4*1024)-sizeof(int))
                        : "d1", "d2", "d3", "d4", "d5", "d6", "d7", "a0", "a1", "a2", "a3",
                          "a4", "a5", "memory"
                        );
                rv = asm_rv;
        }
        else {

                __asm__ __volatile__ (
                        "movl	%%sp,main_sp\n\t"
                        "movl	%%a6,main_fp\n\t"
                        "movl	gunzip_jumpback,%%a0\n\t"
                        "jmp	%%a0@"
                        :
                        :
                        : "d0", "d1", "a0", "a1", "memory"
                        );
        }
        return( rv );
}
# 258 "gunzip_mod.c"
static int fill_inbuf( void )
{
    if (exit_code)
                return( -1 );

    insize = sread( inbuf, (32*1024) );
    if (insize <= 0)
                return( -1 );

    inptr = 1;
    return( inbuf[0] );
}





static void flush_window( void )
{
    ulg c = crc;
    unsigned n;
    uch *in, ch;

    in = window;
    for( n = 0; n < outcnt; n++ ) {
            ch = *in++;
            c = crc_32_tab[((int)c ^ ch) & 0xff] ^ (c >> 8);
    }
    crc = c;
        bytes_out += (ulg)outcnt;





        __asm__ __volatile__ ( "movml	%%d2-%%d7/%%a2-%%a6,%%sp@-\n\t" "movl	%%sp,gunzip_sp\n\t" "movl	#1f,gunzip_jumpback\n\t" "movl	outcnt,%%d0\n\t" "jmp	_return_from_flush\n" "1:\tmovl	gunzip_sp,%%sp\n\t" "movml	%%sp@+,%%d2-%%d7/%%a2-%%a6" : : : "d0", "d1", "a0", "a1", "memory" );

        outcnt = 0;
}

static void error( char *x )
{
    printf( "\n%s\n", x);
    exit_code = 1;
}