Index: conf/files =================================================================== RCS file: /home/ncvs/src/sys/conf/files,v retrieving revision 1.340.2.51 diff -u -r1.340.2.51 files --- conf/files 2001/03/05 05:33:20 1.340.2.51 +++ conf/files 2001/07/10 15:14:45 @@ -896,6 +896,7 @@ nfs/nfs_syscalls.c optional nfs nfs/nfs_vfsops.c optional nfs nfs/nfs_vnops.c optional nfs +kern/embuf.c optional nfs nfs/bootp_subr.c optional bootp nfs/krpc_subr.c optional bootp nwfs/nwfs_io.c optional nwfs Index: conf/options =================================================================== RCS file: /home/ncvs/src/sys/conf/options,v retrieving revision 1.191.2.22 diff -u -r1.191.2.22 options --- conf/options 2001/04/05 17:23:43 1.191.2.22 +++ conf/options 2001/05/17 18:47:09 @@ -342,6 +342,7 @@ DEBUG_VFS_LOCKS opt_global.h DIAGNOSTIC opt_global.h ENABLE_VFS_IOOPT opt_global.h +ZERO_COPY_SOCKETS opt_global.h INVARIANT_SUPPORT opt_global.h INVARIANTS opt_global.h SIMPLELOCK_DEBUG opt_global.h Index: kern/kern_subr.c =================================================================== RCS file: /home/ncvs/src/sys/kern/kern_subr.c,v retrieving revision 1.31 diff -u -r1.31 kern_subr.c --- kern/kern_subr.c 1999/10/29 18:08:51 1.31 +++ kern/kern_subr.c 2001/05/17 20:02:39 @@ -54,6 +54,81 @@ static void uio_yield __P((void)); +#if defined(ZERO_COPY_SOCKETS) +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static int vm_pgmoveco __P((vm_map_t, vm_object_t, vm_offset_t, + vm_offset_t)); +static int userspaceco __P((caddr_t, u_int, struct uio *, + struct vm_object *, int)); +extern int zcs_enable; + +static int +vm_pgmoveco(mapa, srcobj, kaddr, uaddr) + vm_map_t mapa; + vm_object_t srcobj; + vm_offset_t kaddr, uaddr; +{ + vm_map_t map = mapa; + vm_page_t kern_pg, user_pg; + vm_object_t uobject; + vm_map_entry_t entry; + vm_pindex_t upindex, kpindex; + vm_prot_t prot; + boolean_t wired; + + /* + * First lookup the kernel page. + */ + kern_pg = PHYS_TO_VM_PAGE(vtophys(kaddr)); + + if ((vm_map_lookup(&map, uaddr, + VM_PROT_READ, &entry, &uobject, + &upindex, &prot, &wired)) != KERN_SUCCESS) { + return(EFAULT); + } + if ((user_pg = vm_page_lookup(uobject, upindex)) != NULL) { + vm_page_sleep_busy(user_pg, 1, "vm_pgmoveco"); + pmap_remove(map->pmap, uaddr, uaddr+PAGE_SIZE); + vm_page_busy(user_pg); + vm_page_free(user_pg); + } + + if (kern_pg->busy || ((kern_pg->queue - kern_pg->pc) == PQ_FREE) || + (kern_pg->hold_count != 0)|| (kern_pg->flags & PG_BUSY)) { + printf("vm_pgmoveco: pindex(%lu), busy(%d), PG_BUSY(%d), " + "hold(%d) paddr(0x%lx)\n", (u_long)kern_pg->pindex, + kern_pg->busy, (kern_pg->flags & PG_BUSY) ? 1 : 0, + kern_pg->hold_count, (u_long)kern_pg->phys_addr); + if ((kern_pg->queue - kern_pg->pc) == PQ_FREE) + panic("vm_pgmoveco: renaming free page"); + else + panic("vm_pgmoveco: renaming busy page"); + } + kpindex = kern_pg->pindex; + vm_page_busy(kern_pg); + vm_page_rename(kern_pg, uobject, upindex); + vm_page_flag_clear(kern_pg, PG_BUSY); + kern_pg->valid = VM_PAGE_BITS_ALL; + + vm_map_lookup_done(map, entry); + return(KERN_SUCCESS); +} +#endif /* ZERO_COPY_SOCKETS */ + int uiomove(cp, n, uio) register caddr_t cp; @@ -121,12 +196,96 @@ return (error); } +static int +userspaceco(cp, cnt, uio, obj, disposable) + caddr_t cp; + u_int cnt; + struct uio *uio; + struct vm_object *obj; + int disposable; +{ + struct iovec *iov; + int error; + + iov = uio->uio_iov; + +#if defined(ZERO_COPY_SOCKETS) && defined(ENABLE_VFS_IOOPT) + + if (uio->uio_rw == UIO_READ) { + if ((obj != NULL) + && ((cnt & PAGE_MASK) == 0) + && ((((intptr_t) iov->iov_base) & PAGE_MASK) == 0) + && ((uio->uio_offset & PAGE_MASK) == 0) + && ((((intptr_t) cp) & PAGE_MASK) == 0)) { + if (zcs_enable + && (obj->type == OBJT_DEFAULT) + && (disposable != 0)) { + /* SOCKET: use page-trading */ + /* + * We only want to call vm_pgmoveco() on + * disposeable pages, since it gives the + * kernel page to the userland process. + */ + error = vm_pgmoveco(&curproc->p_vmspace->vm_map, + obj, (vm_offset_t)cp, + (vm_offset_t)iov->iov_base); + + /* + * If we get an error back, attempt + * to use copyout() instead. The + * disposable page should be freed + * automatically if we weren't able to move + * it into userland. + */ + if (error != 0) + error = copyout(cp, iov->iov_base, cnt); + } else { + /* something else, use vm_uiomove */ + if (vfs_ioopt) + error = vm_uiomove(&curproc->p_vmspace->vm_map, + obj, uio->uio_offset, cnt, + (vm_offset_t) iov->iov_base, + NULL); + else + error = copyout(cp, iov->iov_base, cnt); + } + } else { + error = copyout(cp, iov->iov_base, cnt); + } + } else { + error = copyin(iov->iov_base, cp, cnt); + } +#else /*ZERO_COPY_SOCKETS && ENABLE_VFS_IOOPT */ + if (uio->uio_rw == UIO_READ) { +#ifdef ENABLE_VFS_IOOPT + if ((vfs_ioopt != 0) + && ((cnt & PAGE_MASK) == 0) + && ((((intptr_t) iov->iov_base) & PAGE_MASK) == 0) + && ((uio->uio_offset & PAGE_MASK) == 0) + && ((((intptr_t) cp) & PAGE_MASK) == 0)) { + error = vm_uiomove(&curproc->p_vmspace->vm_map, obj, + uio->uio_offset, cnt, + (vm_offset_t) iov->iov_base, NULL); + } else +#endif /* ENABLE_VFS_IOOPT */ + { + error = copyout(cp, iov->iov_base, cnt); + } + } else { + error = copyin(iov->iov_base, cp, cnt); + } +#endif /*ZERO_COPY_SOCKETS && ENABLE_VFS_IOOPT*/ + + return(error); +} + int -uiomoveco(cp, n, uio, obj) +uiomoveco(cp, n, uio, obj, disposable) caddr_t cp; int n; struct uio *uio; struct vm_object *obj; + int disposable; { struct iovec *iov; u_int cnt; @@ -154,23 +313,9 @@ case UIO_USERISPACE: if (ticks - switchticks >= hogticks) uio_yield(); - if (uio->uio_rw == UIO_READ) { -#ifdef ENABLE_VFS_IOOPT - if (vfs_ioopt && ((cnt & PAGE_MASK) == 0) && - ((((intptr_t) iov->iov_base) & PAGE_MASK) == 0) && - ((uio->uio_offset & PAGE_MASK) == 0) && - ((((intptr_t) cp) & PAGE_MASK) == 0)) { - error = vm_uiomove(&curproc->p_vmspace->vm_map, obj, - uio->uio_offset, cnt, - (vm_offset_t) iov->iov_base, NULL); - } else -#endif - { - error = copyout(cp, iov->iov_base, cnt); - } - } else { - error = copyin(iov->iov_base, cp, cnt); - } + + error = userspaceco(cp, cnt, uio, obj, disposable); + if (error) return (error); break; @@ -427,4 +572,209 @@ p->p_stats->p_ru.ru_nivcsw++; mi_switch(); splx(s); +} + +/*- + * Copyright (c) 1997-2001, Duke University + * All rights reserved. + * + * Author: + * Andrew Gallatin + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgements: + * This product includes software developed by Duke University + * 4. The name of Duke University may not be used to endorse or promote + * products derived from this software without specific prior written + * permission. + * + * THIS SOFTWARE IS PROVIDED BY DUKE UNIVERSITY ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL DUKE UNIVERSITY BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITSOR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * $FreeBSD$ + */ +/* + * This is a set of routines for enabling and disabling copy on write + * protection for data written into sockets. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +struct netsend_cow_stats { + int attempted; + int fail_not_mapped; + int fail_wired; + int fail_not_anon; + int fail_pmap_cow; + int fail_pg_error; + int fail_kva; + int free_post_exit; + int success; + int iodone; + int freed; +}; + +static struct netsend_cow_stats socow_stats = {0,0,0,0,0,0,0,0,0,0,0}; + +extern struct sf_buf *sf_bufs; +extern vm_offset_t sf_base; +#define dtosf(x) (&sf_bufs[((uintptr_t)(x) - (uintptr_t)sf_base) >> PAGE_SHIFT]) +void sf_buf_free(caddr_t addr, void *args); +struct sf_buf *sf_buf_alloc(void); +void sf_buf_ref(caddr_t addr, u_int size); +static void socow_iodone __P((caddr_t addr, u_int len)); + +static void +socow_iodone(addr, len) + caddr_t addr; + u_int len; +{ + int s; + struct sf_buf *sf; + + vm_offset_t paddr; + vm_page_t pp; + + sf = dtosf(addr); + if (sf->refcnt == 0) + panic("sf_buf_free: freeing free sf_buf"); + if(sf->refcnt > 1) + sf->refcnt--; + else { + paddr = vtophys((vm_offset_t)addr); + pp = PHYS_TO_VM_PAGE(paddr); + s = splvm(); + /* remove COW mapping */ + vm_page_cowclear(pp); + if (pp->object && pp->object->ref_count) + vm_object_deallocate(pp->object); + splx(s); + /* note that sf_buf_free() unwires the page for us*/ + sf_buf_free(addr, NULL); + } + socow_stats.iodone++; +} + +int +socow_setup(m0, uio) + struct mbuf *m0; + struct uio *uio; +{ + struct sf_buf *sf; + vm_page_t pp; + vm_offset_t pa; + struct iovec *iov; + struct vmspace *vmspace; + struct vm_map *map; + vm_offset_t uva; + int s; + + vmspace = curproc->p_vmspace;; + map = &vmspace->vm_map; + uva = (vm_offset_t) uio->uio_iov->iov_base; + + s = splvm(); + + /* + * verify page is mapped & not already wired for i/o + */ + socow_stats.attempted++; + pa=pmap_extract(map->pmap, uva); + if(!pa) { + socow_stats.fail_not_mapped++; + splx(s); + return(0); + } + pp = PHYS_TO_VM_PAGE(pa); + + sf = sf_buf_alloc(); + sf->m = pp; + pmap_qenter(sf->kva, &pp, 1); + + /* + * set up COW + */ + vm_page_cowsetup(pp); + + /* + * wire the page for I/O + */ + vm_page_wire(pp); + + /* + * prevent the process from exiting on us. + */ + vm_object_reference(pp->object); + + /* + * attach to mbuf + */ + m0->m_data = m0->m_ext.ext_buf = (caddr_t)sf->kva; + m0->m_len = PAGE_SIZE; + m0->m_ext.ext_size = PAGE_SIZE; + m0->m_ext.ext_free = socow_iodone; + m0->m_ext.ext_ref = sf_buf_ref; + m0->m_flags |= (M_EXT); + socow_stats.success++; + + + iov = uio->uio_iov; + iov->iov_base += PAGE_SIZE; + iov->iov_len -= PAGE_SIZE; + uio->uio_resid -= PAGE_SIZE; + uio->uio_offset += PAGE_SIZE; + if (iov->iov_len == 0) { + uio->uio_iov++; + uio->uio_iovcnt--; + } + + + splx(s); + return(1); } Index: kern/uipc_mbuf.c =================================================================== RCS file: /home/ncvs/src/sys/kern/uipc_mbuf.c,v retrieving revision 1.51.2.3 diff -u -r1.51.2.3 uipc_mbuf.c --- kern/uipc_mbuf.c 2000/08/25 23:23:32 1.51.2.3 +++ kern/uipc_mbuf.c 2001/05/17 18:56:38 @@ -1198,3 +1198,267 @@ } return; } + +/* + * Copyright (c) 1999-2001, Duke University + * All rights reserved. + * + * Author: + * Andrew Gallatin + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgements: + * This product includes software developed by Duke University + * 4. The name of Duke University may not be used to endorse or promote + * products derived from this software without specific prior written + * permission. + * + * THIS SOFTWARE IS PROVIDED BY DUKE UNIVERSITY ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL DUKE UNIVERSITY BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITSOR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* XXX KDM XXX */ +#define JUMBO_MAX_PAGES 8192 + +SLIST_HEAD(jumbo_kmap_head, jumbo_kmap) jumbo_kmap_free, jumbo_kmap_inuse; + struct jumbo_kmap { + vm_offset_t kva; + SLIST_ENTRY(jumbo_kmap) entries; /* Singly-linked List. */ + }; + + +struct vm_object *jumbo_vm_object; +unsigned long jumbo_vmuiomove_pgs_freed=0; +int jumbo_vm_wakeup_wanted=0; +vm_offset_t jumbo_basekva; +/* XXX KDM XXX */ + + +caddr_t +jumbo_phys_to_kva (vm_offset_t pa) +{ + vm_page_t pg = PHYS_TO_VM_PAGE(pa); + pg->flags &= ~PG_BUSY; + return (caddr_t)(ptoa(pg->pindex) + jumbo_basekva); +} + +int +jumbo_vm_init(void) +{ + int i; + struct jumbo_kmap *entry; + + if(jumbo_vm_object) + return(1); +/* allocate our object */ + jumbo_vm_object = vm_object_allocate(OBJT_DEFAULT, JUMBO_MAX_PAGES); + +/* grab some kernel virtual address space */ + SLIST_INIT(&jumbo_kmap_free); + SLIST_INIT(&jumbo_kmap_inuse); + jumbo_basekva = kmem_alloc_pageable(kernel_map, PAGE_SIZE * JUMBO_MAX_PAGES); + if(jumbo_basekva == 0) { + vm_object_deallocate(jumbo_vm_object); + jumbo_vm_object = NULL; + return 0; + } + for (i = 0; i < JUMBO_MAX_PAGES; i++){ + entry = malloc(sizeof(struct jumbo_kmap), M_TEMP, M_WAITOK); + if(!entry && !i) + panic("jumbo unable to allocated kvas"); + else if(!entry){ + printf("warning: ti allocated only %d kva\n",i); + return 1; + } + entry->kva = jumbo_basekva + (vm_offset_t)i * PAGE_SIZE; + SLIST_INSERT_HEAD(&jumbo_kmap_free, entry, entries); + } + return 1; +} + +void +jumbo_freem(caddr_t addr, u_int len) +{ + register int s; + vm_page_t frame = PHYS_TO_VM_PAGE(pmap_kextract((vm_offset_t)addr)); + s = splimp(); + if((frame->object == jumbo_vm_object) && (frame->hold_count)){ + frame->hold_count--; + } else{ + jumbo_pg_free((vm_offset_t)addr); + } + splx(s); +} + +void +jumbo_ref(caddr_t addr, u_int len) +{ + vm_page_t frame = PHYS_TO_VM_PAGE(pmap_kextract((vm_offset_t)addr)); + frame->hold_count++; +} + +/* + * somewhat racy -- this is only safe if called when we "know" + * that no other thread can aquire a reference to our mbuf + */ + +int +jumbo_disposable(caddr_t addr) +{ + vm_page_t frame = PHYS_TO_VM_PAGE(pmap_kextract((vm_offset_t)addr)); + + if (frame->object != jumbo_vm_object) + return 0; + if (frame->hold_count) + return 0; + return 1; +} + +void +jumbo_pg_steal(vm_page_t pg) +{ + vm_offset_t addr = ptoa(pg->pindex) + jumbo_basekva; + struct jumbo_kmap *entry; + int s; + if(pg->object != jumbo_vm_object) + panic("stealing a non jumbo_vm_object page"); + vm_page_remove(pg); + s = splvm(); + pmap_qremove(addr,1); + entry = jumbo_kmap_inuse.slh_first; + entry->kva = addr; + SLIST_REMOVE_HEAD(&jumbo_kmap_inuse, entries); + SLIST_INSERT_HEAD(&jumbo_kmap_free, entry, entries); + splx(s); + if(jumbo_vm_wakeup_wanted) + wakeup(jumbo_vm_object); +} + + +vm_page_t +jumbo_pg_alloc(void) +{ + vm_page_t pg = NULL; + vm_pindex_t pindex; + struct jumbo_kmap *entry; + int s = splvm(); + + entry = jumbo_kmap_free.slh_first; + if(entry != NULL){ + pindex = atop(entry->kva - jumbo_basekva); + pg = vm_page_alloc(jumbo_vm_object, pindex, VM_ALLOC_INTERRUPT); + if(pg != NULL){ + SLIST_REMOVE_HEAD(&jumbo_kmap_free, entries); + SLIST_INSERT_HEAD(&jumbo_kmap_inuse, entry, entries); + pmap_qenter(entry->kva, &pg, 1); + } + } + splx(s); + return(pg); +} + +void +jumbo_pg_free(vm_offset_t addr) +{ + int s; + struct jumbo_kmap *entry; + vm_offset_t paddr = pmap_kextract((vm_offset_t)addr); + vm_page_t pg = PHYS_TO_VM_PAGE(paddr); + + + if(pg->object != jumbo_vm_object){ + jumbo_vmuiomove_pgs_freed++; +/* if(vm_page_lookup(jumbo_vm_object, atop(addr - jumbo_basekva))) + panic("vm_page_rename didn't"); + printf("freeing uiomoved pg:\t pindex = %d, padd = 0x%lx\n", + atop(addr - jumbo_basekva), paddr); +*/ + } else { + vm_page_busy(pg); /* vm_page_free wants pages to be busy*/ + vm_page_free(pg); + } + s = splvm(); + pmap_qremove(addr,1); + entry = jumbo_kmap_inuse.slh_first; + entry->kva = addr; + SLIST_REMOVE_HEAD(&jumbo_kmap_inuse, entries); + SLIST_INSERT_HEAD(&jumbo_kmap_free, entry, entries); + splx(s); + if(jumbo_vm_wakeup_wanted) + wakeup(jumbo_vm_object); +} + +#if 0 +/* + * deallocate jumbo buffers & vm object + * NOTE: There may still be some ext. mbufs floating around + * which point at our pages. We must wait until the + * jumbo_vm_object is empty before deallocating it. + */ + +static void +jumbo_free_jumbos(device_t dev) +{ + + int i, s; + struct jumbo_kmap *entry, *next_entry; + + s = splvm(); + + while(jumbo_vm_object->resident_page_count){ + device_printf(dev, "jumbo_free_jumbos: jumbo_vm_object has %d resident pages remaining, sleeping..\n", + jumbo_vm_object->resident_page_count); + jumbo_vm_wakeup_wanted = 1; + tsleep(jumbo_vm_object, PVM, "jumbo_free_jumbos", 0); + } + /* + * Free queue structures + */ + + next_entry = SLIST_FIRST(&jumbo_kmap_free); + entry = next_entry; + i = 0; + while(entry) { + next_entry = SLIST_NEXT(entry, entries); + free(entry, M_TEMP); + entry = next_entry; + i++; + } + if(i != JUMBO_MAX_PAGES) { + device_printf(dev, "DANGER, DANGER! freed only %d kmap_entries (out of %d)\n", + i, JUMBO_MAX_PAGES); + } + vm_object_deallocate(jumbo_vm_object); + jumbo_vm_object = NULL; + splx(s); +} +#endif Index: kern/uipc_socket.c =================================================================== RCS file: /home/ncvs/src/sys/kern/uipc_socket.c,v retrieving revision 1.68.2.15 diff -u -r1.68.2.15 uipc_socket.c --- kern/uipc_socket.c 2001/03/09 16:41:20 1.68.2.15 +++ kern/uipc_socket.c 2001/05/17 19:21:32 @@ -89,6 +89,26 @@ SYSCTL_INT(_kern_ipc, KIPC_SOMAXCONN, somaxconn, CTLFLAG_RW, &somaxconn, 0, "Maximum pending socket connection queue size"); +#ifdef ZERO_COPY_SOCKETS +#include +#include +#include +#include +#include +#include + +int zcs_enable = 0; +struct so_zerocopy_stats{ + int size_ok; + int align_ok; + int found_ifp; +}; +struct so_zerocopy_stats so_zerocp_stats = {0,0,0}; + +SYSCTL_INT(_kern_ipc, 0, zcs_enable, CTLFLAG_RW, + &zcs_enable, 0, "enable zero copy sockets"); + +#endif /* * Socket operation routines. * These routines are called by the routines in @@ -460,6 +480,9 @@ register long space, len, resid; int clen = 0, error, s, dontroute, mlen; int atomic = sosendallatonce(so) || top; +#ifdef ZERO_COPY_SOCKETS + int cow_send; +#endif if (uio) resid = uio->uio_resid; @@ -548,6 +571,9 @@ if (flags & MSG_EOR) top->m_flags |= M_EOR; } else do { +#ifdef ZERO_COPY_SOCKETS + cow_send = 0; +#endif if (top == 0) { MGETHDR(m, M_WAIT, MT_DATA); if (m == NULL) { @@ -566,12 +592,30 @@ mlen = MLEN; } if (resid >= MINCLSIZE) { +#ifdef ZERO_COPY_SOCKETS + if (zcs_enable && resid >= PAGE_SIZE && + space >= PAGE_SIZE && + uio->uio_iov->iov_len>=PAGE_SIZE) { + so_zerocp_stats.size_ok++; + if(!((vm_offset_t) + uio->uio_iov->iov_base & PAGE_MASK)){ + so_zerocp_stats.align_ok++; + cow_send = socow_setup(m, uio); + } + } + if (!cow_send) { +#endif MCLGET(m, M_WAIT); if ((m->m_flags & M_EXT) == 0) goto nopages; mlen = MCLBYTES; len = min(min(mlen, resid), space); } else { +#ifdef ZERO_COPY_SOCKETS + len = PAGE_SIZE; + } + } else { +#endif nopages: len = min(min(mlen, resid), space); /* @@ -582,7 +626,12 @@ MH_ALIGN(m, len); } space -= len; +#ifdef ZERO_COPY_SOCKETS + if (cow_send) + error = 0; + else error = uiomove(mtod(m, caddr_t), (int)len, uio); +#endif resid = uio->uio_resid; m->m_len = len; *mp = m; @@ -693,6 +742,26 @@ if (error) goto bad; do { +#if defined(ZERO_COPY_SOCKETS) && defined(ENABLE_VFS_IOOPT) + if (zcs_enable) { + vm_page_t pg; + int disposable; + + if ((m->m_flags & M_EXT) + && jumbo_disposable(mtod(m, caddr_t))) + disposable = 1; + else + disposable = 0; + + pg = PHYS_TO_VM_PAGE(vtophys(mtod(m, caddr_t))); + if (uio->uio_offset == -1) + uio->uio_offset = IDX_TO_OFF(pg->pindex); + + error = uiomoveco(mtod(m, caddr_t), + min(uio->uio_resid, m->m_len), + uio, pg->object, disposable); + } else +#endif /*ZERO_COPY_SOCKETS && ENABLE_VFS_IOOPT*/ error = uiomove(mtod(m, caddr_t), (int) min(uio->uio_resid, m->m_len), uio); m = m_free(m); @@ -846,6 +915,26 @@ */ if (mp == 0) { splx(s); +#if defined(ZERO_COPY_SOCKETS) && defined(ENABLE_VFS_IOOPT) + if (zcs_enable) { + vm_page_t pg; + int disposable; + + if ((m->m_flags & M_EXT) + && jumbo_disposable(mtod(m, caddr_t) + moff)) + disposable = 1; + else + disposable = 0; + + pg = PHYS_TO_VM_PAGE(vtophys(mtod(m, caddr_t) + moff)); + if (uio->uio_offset == -1) + uio->uio_offset = IDX_TO_OFF(pg->pindex); + + error = uiomoveco(mtod(m, caddr_t) + moff, + min(uio->uio_resid, m->m_len), + uio, pg->object, disposable); + } else +#endif /*ZERO_COPY_SOCKETS && ENABLE_VFS_IOOPT*/ error = uiomove(mtod(m, caddr_t) + moff, (int)len, uio); s = splnet(); if (error) Index: kern/uipc_syscalls.c =================================================================== RCS file: /home/ncvs/src/sys/kern/uipc_syscalls.c,v retrieving revision 1.65.2.7 diff -u -r1.65.2.7 uipc_syscalls.c --- kern/uipc_syscalls.c 2001/02/24 18:37:26 1.65.2.7 +++ kern/uipc_syscalls.c 2001/05/17 19:23:00 @@ -71,9 +71,9 @@ static void sf_buf_init(void *arg); SYSINIT(sock_sf, SI_SUB_MBUF, SI_ORDER_ANY, sf_buf_init, NULL) -static struct sf_buf *sf_buf_alloc(void); -static void sf_buf_ref(caddr_t addr, u_int size); -static void sf_buf_free(caddr_t addr, u_int size); +struct sf_buf *sf_buf_alloc(void); +void sf_buf_ref(caddr_t addr, u_int size); +void sf_buf_free(caddr_t addr, u_int size); static int sendit __P((struct proc *p, int s, struct msghdr *mp, int flags)); static int recvit __P((struct proc *p, int s, struct msghdr *mp, @@ -86,9 +86,9 @@ int compat)); static SLIST_HEAD(, sf_buf) sf_freelist; -static vm_offset_t sf_base; -static struct sf_buf *sf_bufs; -static int sf_buf_alloc_want; +vm_offset_t sf_base; +struct sf_buf *sf_bufs; +int sf_buf_alloc_want; /* * System call interface to the socket abstraction. @@ -1436,7 +1436,7 @@ /* * Get an sf_buf from the freelist. Will block if none are available. */ -static struct sf_buf * +struct sf_buf * sf_buf_alloc() { struct sf_buf *sf; @@ -1454,7 +1454,7 @@ } #define dtosf(x) (&sf_bufs[((uintptr_t)(x) - (uintptr_t)sf_base) >> PAGE_SHIFT]) -static void +void sf_buf_ref(caddr_t addr, u_int size) { struct sf_buf *sf; @@ -1471,7 +1471,7 @@ * * Must be called at splimp. */ -static void +void sf_buf_free(caddr_t addr, u_int size) { struct sf_buf *sf; Index: modules/md/Makefile =================================================================== RCS file: /home/ncvs/src/sys/modules/md/Makefile,v retrieving revision 1.3 diff -u -r1.3 Makefile --- modules/md/Makefile 1999/11/28 18:52:57 1.3 +++ modules/md/Makefile 2001/05/18 17:53:41 @@ -1,8 +1,9 @@ # $FreeBSD: src/sys/modules/md/Makefile,v 1.3 1999/11/28 18:52:57 bde Exp $ -.PATH: ${.CURDIR}/../../dev/md +.PATH: ${.CURDIR}/../../dev/md + KMOD= md -SRCS= md.c opt_mfs.h opt_md.h +SRCS= md.c opt_mfs.h opt_md.h vnode_if.h NOMAN= .include Index: modules/mii/Makefile =================================================================== RCS file: /home/ncvs/src/sys/modules/mii/Makefile,v retrieving revision 1.11.2.2 diff -u -r1.11.2.2 Makefile --- modules/mii/Makefile 2000/10/03 18:46:55 1.11.2.2 +++ modules/mii/Makefile 2001/07/02 19:07:31 @@ -6,5 +6,6 @@ SRCS += miibus_if.h device_if.h miibus_if.c exphy.c nsphy.c SRCS += mlphy.c tlphy.c rlphy.c amphy.c dcphy.c pnphy.c SRCS += pnaphy.c brgphy.c xmphy.c +SRCS += nsgphy.c .include Index: modules/ti/Makefile =================================================================== RCS file: /home/ncvs/src/sys/modules/ti/Makefile,v retrieving revision 1.8 diff -u -r1.8 Makefile --- modules/ti/Makefile 2000/01/28 11:26:38 1.8 +++ modules/ti/Makefile 2001/05/14 15:34:35 @@ -2,7 +2,7 @@ .PATH: ${.CURDIR}/../../pci KMOD = if_ti -SRCS = if_ti.c opt_bdg.h vlan.h device_if.h bus_if.h pci_if.h +SRCS = if_ti.c opt_bdg.h vlan.h device_if.h bus_if.h pci_if.h vnode_if.h CLEANFILES = vlan.h vlan.h: Index: netinet/ip_output.c =================================================================== RCS file: /home/ncvs/src/sys/netinet/ip_output.c,v retrieving revision 1.99.2.13 diff -u -r1.99.2.13 ip_output.c --- netinet/ip_output.c 2001/03/11 22:18:00 1.99.2.13 +++ netinet/ip_output.c 2001/05/18 21:38:47 @@ -466,6 +466,21 @@ if (m) m_freem(m); error = EACCES ; +#if 1 + /* + * [for slice] ipfw_hook may claim the outgoing + * packet without generating an error. if + * ip_fw_chk_ptr returned our magic number, then + * return success. + * + * without this modification, slice packet + * redirection will generate "nfs send error 13" + * messages on the console. + */ + if (off & 0x30000) + error = 0; +#endif + goto done ; } ip = mtod(m, struct ip *); @@ -835,8 +850,50 @@ m->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA; } + if (len > PAGE_SIZE) { + /* + * Fragement large datagrams such that each segment + * contains a multiple of PAGE_SIZE amount of data, + * plus headers. This enables a receiver to perform + * page-flipping zero-copy optimizations. + */ + + int newlen; + struct mbuf *mtmp; + + for (mtmp = m, off = 0; + mtmp && ((off + mtmp->m_len) <= ifp->if_mtu); + mtmp = mtmp->m_next) { + off += mtmp->m_len; + } + /* + * firstlen (off - hlen) must be aligned on an + * 8-byte boundary + */ + if (off < hlen) + goto smart_frag_failure; + off = ((off - hlen) & ~7) + hlen; + newlen = (~PAGE_MASK) & ifp->if_mtu; + if ((newlen + sizeof (struct ip)) > ifp->if_mtu) { + /* we failed, go back the default */ +smart_frag_failure: + newlen = len; + off = hlen + len; + } + +/* printf("ipfrag: len = %d, hlen = %d, mhlen = %d, newlen = %d, off = %d\n", + len, hlen, sizeof (struct ip), newlen, off);*/ + + len = newlen; + + } else { + off = hlen + len; + } + + + { - int mhlen, firstlen = len; + int mhlen, firstlen = off - hlen; struct mbuf **mnext = &m->m_nextpkt; int nfrags = 1; @@ -846,7 +903,7 @@ */ m0 = m; mhlen = sizeof (struct ip); - for (off = hlen + len; off < (u_short)ip->ip_len; off += len) { + for (; off < (u_short)ip->ip_len; off += len) { MGETHDR(m, M_DONTWAIT, MT_HEADER); if (m == 0) { error = ENOBUFS; Index: nfs/nfs_bio.c =================================================================== RCS file: /home/ncvs/src/sys/nfs/nfs_bio.c,v retrieving revision 1.83 diff -u -r1.83 nfs_bio.c --- nfs/nfs_bio.c 2000/01/05 05:11:36 1.83 +++ nfs/nfs_bio.c 2001/07/03 14:01:21 @@ -47,6 +47,7 @@ #include #include #include +#include #include #include @@ -320,6 +321,8 @@ return rtvals[0]; } +int nfs_read_cache_disable = 0; + /* * Vnode op for read using bio */ @@ -535,6 +538,12 @@ } } + if (nfs_read_cache_disable) { + /* no client caching - force re-read from remote */ + bp->b_flags |= B_NOCACHE; + bp->b_flags |= B_INVAL; + } + /* * on is the offset into the current bp. Figure out how many * bytes we can copy out of the bp. Note that bcount is @@ -682,7 +691,25 @@ }; if (n > 0) { - error = uiomove(bp->b_data + on, (int)n, uio); +#ifdef ENABLE_VFS_IOOPT + if (vfs_ioopt && vp->v_object && + (bp->b_flags & B_VMIO) && + ((on & PAGE_MASK) == 0) && + ((n & PAGE_MASK) == 0)) + /* + * If VFS IO optimisation is turned on, + * and it's an exact page multiple + * And a normal VM based op, + * then use uiomiveco() + */ + error = + uiomoveco((char *)bp->b_data + on, + (int)n, uio, vp->v_object, 0); + else + +#endif + error = uiomove(bp->b_data + on, (int)n, uio); + } switch (vp->v_type) { case VREG: @@ -1340,6 +1367,12 @@ * Do an I/O operation to/from a cache block. This may be called * synchronously or from an nfsiod. */ + +static int nfs_cluster_commit __P((struct vnode *vp, struct buf *bp, + struct proc *p)); +int nfs_zreadrpc __P((struct buf *, struct vnode *, struct uio *, + struct ucred *)); + int nfs_doio(bp, cr, p) struct buf *bp; @@ -1407,7 +1440,7 @@ case VREG: uiop->uio_offset = ((off_t)bp->b_blkno) * DEV_BSIZE; nfsstats.read_bios++; - error = nfs_readrpc(vp, uiop, cr); + error = nfs_zreadrpc(bp, vp, uiop, cr); if (!error) { if (uiop->uio_resid) { /* @@ -1473,24 +1506,10 @@ */ if (bp->b_flags & B_NEEDCOMMIT) { int retv; - off_t off; - off = ((u_quad_t)bp->b_blkno) * DEV_BSIZE + bp->b_dirtyoff; - bp->b_flags |= B_WRITEINPROG; - retv = nfs_commit( - bp->b_vp, off, bp->b_dirtyend-bp->b_dirtyoff, - bp->b_wcred, p); - bp->b_flags &= ~B_WRITEINPROG; - if (retv == 0) { - bp->b_dirtyoff = bp->b_dirtyend = 0; - bp->b_flags &= ~(B_NEEDCOMMIT | B_CLUSTEROK); - bp->b_resid = 0; - biodone(bp); + retv = nfs_cluster_commit(vp, bp, p); + if (retv == 0) return (0); - } - if (retv == NFSERR_STALEWRITEVERF) { - nfs_clearcommit(bp->b_vp->v_mount); - } } /* @@ -1591,3 +1610,203 @@ biodone(bp); return (error); } + + +#ifndef NFS_COMMITBVECSIZ +#define NFS_COMMITBVECSIZ 20 +#endif +int nfs_cluster_commitbufs = 2048; +/* + * nfs_cluster_commit(vp, bp, p) + * + * This function is called on a NFS buffer that needs a commit RPC + * Even though the buffer may already be clustered, clustering is limited + * to 64k chunks, try to grab an even bigger range by scanning forward and + * backward in the file. + */ +static int +nfs_cluster_commit(vp, bp, p) + struct vnode *vp; + struct buf *bp; + struct proc *p; +{ + struct buf **cbufs, *cbufs_on_stack[NFS_COMMITBVECSIZ], *holdbp, *testbp; + int commit_idx, retv, flags, pass, i, dirty_off, dirty_end, s, gap; + int lblocksize; + int maxcbufs; + int pre_count=0, post_count=0; + u_quad_t sblkno, eblkno, lblkno, olblkno; + /* start, end, logical block number */ + + KASSERT(bp->b_flags & B_NEEDCOMMIT, ("NFS commit without B_NEEDCOMMIT")); + + cbufs = NULL; + + if (nfs_cluster_commitbufs > NFS_COMMITBVECSIZ) { + cbufs = (struct buf **) + malloc(nfs_cluster_commitbufs * sizeof(struct buf *), + M_TEMP, M_NOWAIT); + } + + if (cbufs == NULL) { + cbufs = cbufs_on_stack; + maxcbufs = NFS_COMMITBVECSIZ; + } else { + maxcbufs = nfs_cluster_commitbufs; + } + flags = B_DELWRI | B_NEEDCOMMIT; + gap = 0; + commit_idx = 0; + pass = 0; + sblkno = eblkno = (u_quad_t)bp->b_lblkno; + dirty_end = bp->b_dirtyend; + dirty_off = bp->b_dirtyoff; + lblocksize = vp->v_mount->mnt_stat.f_iosize; + + bp->b_flags |= B_WRITEINPROG; + + s = splbio(); + /* + * first pass scan forward, second backwards from bp + */ +pass: + /* reinit the start location for our sweep */ + lblkno = (u_quad_t)bp->b_lblkno; + holdbp = bp; + + /* + * don't scan too much and don't overflow buf pointer array + */ + while (gap < 4 && commit_idx < maxcbufs) { + + /* scan forward or backward */ + if (pass == 1) { /* backwards */ + /* + * backwards is easy just subtracting one from the lbn + * should get us the previous buffer if it exists + */ + if (lblkno == 0) + break; + else + lblkno--; + } else { + /* + * when going forward make sure to remeber to account + * for buffers that span more than one block + * if holdbp == NULL then gbincore() failed, try + * going forward only a single block + */ + if (lblkno == (u_quad_t)-1) + break; + else if (holdbp == NULL) { + lblkno++; + } + else { + olblkno = lblkno; + lblkno += holdbp->b_bufsize / lblocksize; + if (olblkno == lblkno) + lblkno++; + } + } + + testbp = holdbp; + /* + * if the buffer isn't in memory bump the gap count + * and try the next one + */ + holdbp = gbincore(vp, lblkno); + if (holdbp == NULL) { + gap++; + continue; + } + if (testbp == holdbp) { + gap++; + continue; + } + + lblkno = (u_quad_t)holdbp->b_lblkno; + + /* + * make sure flags and cred are the same as the first buffer + * also make sure we can lock the buffer + * if not we have to escape the loop + */ + if (((holdbp->b_flags & flags) != flags) || + holdbp->b_wcred != bp->b_wcred || + BUF_LOCK(holdbp, LK_EXCLUSIVE | LK_NOWAIT)) + break; + + gap = 0; /* scan more */ + + bremfree(holdbp); /* remove from bufqueues */ + + holdbp->b_flags |= B_WRITEINPROG; + vfs_busy_pages(holdbp, 1); + cbufs[ commit_idx++ ] = holdbp; + if (pass == 1) { + /* going backwards so set start block and offset */ + sblkno = lblkno; + dirty_off = holdbp->b_dirtyoff; + ++pre_count; + } else { + /* going forward so set end block and end pointer */ + eblkno = lblkno; + dirty_end = holdbp->b_dirtyend; + ++post_count; + } + } + gap = 0; + if (++pass == 1) + goto pass; + + splx(s); + + retv = nfs_commit(bp->b_vp, + sblkno * lblocksize + dirty_off, + (eblkno - sblkno) * lblocksize + dirty_end, + bp->b_wcred, p); + + for (i = 0; i < commit_idx; i++) { + holdbp = cbufs[i]; + holdbp->b_flags &= ~(B_WRITEINPROG|B_NEEDCOMMIT); + if (retv) { + /* + * Error, leave B_DELWRI intact + */ + vfs_unbusy_pages(holdbp); + brelse(holdbp); + } else { + /* + * Success, remove B_DELWRI ( bundirty() ). + * + * b_dirtyoff/b_dirtyend seem to be NFS + * specific. We should probably move that + * into bundirty(). XXX + */ + s = splbio(); + vp->v_numoutput++; + holdbp->b_flags |= B_ASYNC; + bundirty(holdbp); + holdbp->b_flags &= ~(B_READ|B_DONE|B_ERROR); + holdbp->b_dirtyoff = holdbp->b_dirtyend = 0; + holdbp->b_resid = 0; + splx(s); + biodone(holdbp); + } + } + bp->b_flags &= ~B_WRITEINPROG; + if (retv == 0) { + bp->b_dirtyoff = bp->b_dirtyend = 0; + bp->b_flags &= ~B_NEEDCOMMIT; + bp->b_resid = 0; + biodone(bp); + } else if (retv == NFSERR_STALEWRITEVERF) { + nfs_clearcommit(bp->b_vp->v_mount); + } + + if (cbufs != cbufs_on_stack) + free(cbufs, M_TEMP); + + return (retv); + + } Index: nfs/nfs_serv.c =================================================================== RCS file: /home/ncvs/src/sys/nfs/nfs_serv.c,v retrieving revision 1.93 diff -u -r1.93 nfs_serv.c --- nfs/nfs_serv.c 1999/12/18 19:20:05 1.93 +++ nfs/nfs_serv.c 2001/05/18 14:23:01 @@ -99,6 +99,13 @@ #include #include +#include +#include +#include +extern struct sf_buf *sf_buf_alloc(void); +extern void sf_buf_ref(caddr_t addr, u_int size); +extern void sf_buf_free(caddr_t addr, u_int size); + #ifdef NFSRV_DEBUG #define nfsdbprintf(info) printf info #else @@ -755,6 +762,13 @@ /* * nfs read service */ + +static int nfs_serv_zcread = 1; +static int nfs_serv_zcreadyes = 0, nfs_serv_zcreadno = 0; +SYSCTL_INT(_vfs_nfs, OID_AUTO, serv_zcread, CTLFLAG_RW, &nfs_serv_zcread, 1, ""); +SYSCTL_INT(_vfs_nfs, OID_AUTO, serv_zcread_count, CTLFLAG_RW, &nfs_serv_zcreadyes, 1, ""); +SYSCTL_INT(_vfs_nfs, OID_AUTO, serv_cpread_count, CTLFLAG_RW, &nfs_serv_zcreadno, 1, ""); + int nfsrv_read(nfsd, slp, procp, mrq) struct nfsrv_descript *nfsd; @@ -919,54 +933,237 @@ } len = left = nfsm_rndup(cnt); if (cnt > 0) { - /* - * Generate the mbuf list with the uio_iov ref. to it. - */ - i = 0; - m = m2 = mb; - while (left > 0) { - siz = min(M_TRAILINGSPACE(m), left); - if (siz > 0) { - left -= siz; - i++; + +/* + * BEGIN SUSPECT REGION + * if offset is aligned and len is a multiple of page size, we should + * be able to use bread() to zero-copy read an appropriate struct buf. + * then wrap ext mbufs around it (final m_freem needs to unlock buf) + * and pass it along. hmm. + */ + if (nfs_serv_zcread) { + + /* preconditions: + * len = number of bytes to read. + * vp = valid vnode. + * mb is the header mbuf. + * m2 is a free temp mbuf. + * + * postconditions: + * mb->m_next points at a chain of mbufs containing the + * read data + * left <- 0 + * uiop->uio_offset <- 0 + * off <- nh->nextr <- offset where read ends + * error <- 0 + */ + + struct vm_object *obj; + struct sf_buf *sf; + struct vm_page *pg; + vm_pindex_t pindex; + vm_offset_t pgoff = 0; /* for now */ + int xfsize = PAGE_SIZE; /* for now */ + + m2 = mb; + + left = len; + if ((len & PAGE_SIZE) || (off & PAGE_SIZE)) { + /* + * don't try to read non-aligned offsets and/or + * non-page-sized lengths. + */ + goto normalpath; + } + + vref(vp); + obj = vp->v_object; + if (vp->v_type != VREG || obj == NULL) { + vrele(vp); + goto normalpath; } - if (left > 0) { - MGET(m, M_WAIT, MT_DATA); - MCLGET(m, M_WAIT); - m->m_len = 0; + + for (; left > 0 ; off += xfsize, left -= xfsize) { + pindex = OFF_TO_IDX(off); + + retry_lookup: + /* + * Attempt to look up the page. + * + * Allocate if not found + * + * Wait and loop if busy. + */ + pg = vm_page_lookup(obj, pindex); + + if (pg == NULL) { + pg = vm_page_alloc(obj, pindex, VM_ALLOC_NORMAL); + if (pg == NULL) { + VM_WAIT; + goto retry_lookup; + } + vm_page_wakeup(pg); + } else if (vm_page_sleep_busy(pg, TRUE, "sfpbsy")) { + goto retry_lookup; + } + + /* + * Wire the page so it does not get ripped out from under + * us. + */ + + vm_page_wire(pg); + + /* + * If page is not valid for what we need, initiate I/O + */ + + if (!pg->valid || !vm_page_is_valid(pg, pgoff, xfsize)) { + struct uio auio; + struct iovec aiov; + int bsize; + + /* + * Ensure that our page is still around when the I/O + * completes. + */ + vm_page_io_start(pg); + + /* + * Get the page from backing store. + */ + bsize = vp->v_mount->mnt_stat.f_iosize; + auio.uio_iov = &aiov; + auio.uio_iovcnt = 1; + aiov.iov_base = 0; + aiov.iov_len = MAXBSIZE; + auio.uio_resid = MAXBSIZE; + auio.uio_offset = trunc_page(off); + auio.uio_segflg = UIO_NOCOPY; + auio.uio_rw = UIO_READ; + auio.uio_procp = procp; + vn_lock(vp, LK_SHARED | LK_NOPAUSE | LK_RETRY, procp); + error = VOP_READ(vp, &auio, IO_VMIO | ((MAXBSIZE / bsize) << 16), + cred); + VOP_UNLOCK(vp, 0, procp); + vm_page_flag_clear(pg, PG_ZERO); + vm_page_io_finish(pg); + if (error) { + vm_page_unwire(pg, 0); + /* + * See if anyone else might know about this page. + * If not and it is not valid, then free it. + */ + if (pg->wire_count == 0 && pg->valid == 0 && + pg->busy == 0 && !(pg->flags & PG_BUSY) && + pg->hold_count == 0) { + if ((pg->flags & PG_BUSY) == 0) { + vm_page_busy(pg); + } + vm_page_free(pg); + } + goto errorpath; + } + } + + /* + * Allocate a kernel virtual page and insert the physical page + * into it. + */ + + sf = sf_buf_alloc(); + sf->m = pg; + pmap_qenter(sf->kva, &pg, 1); + /* + * Get an mbuf header and set it up as having external storage. + */ + MGETHDR(m, M_WAIT, MT_DATA); + if (m == NULL) { + error = ENOBUFS; + goto errorpath; + } + m->m_ext.ext_free = sf_buf_free; + m->m_ext.ext_ref = sf_buf_ref; + m->m_ext.ext_buf = (void *)sf->kva; + m->m_ext.ext_size = PAGE_SIZE; + m->m_data = (char *) sf->kva + pgoff; + m->m_flags |= M_EXT; + m->m_pkthdr.len = m->m_len = xfsize; + m2->m_next = m; m2 = m; } - } - MALLOC(iv, struct iovec *, i * sizeof (struct iovec), - M_TEMP, M_WAITOK); - uiop->uio_iov = iv2 = iv; - m = mb; - left = len; - i = 0; - while (left > 0) { - if (m == NULL) - panic("nfsrv_read iov"); - siz = min(M_TRAILINGSPACE(m), left); - if (siz > 0) { - iv->iov_base = mtod(m, caddr_t) + m->m_len; - iv->iov_len = siz; - m->m_len += siz; - left -= siz; - iv++; - i++; + + uiop->uio_resid = 0; + nh->nh_nextr = off; + error = 0; + + nfs_serv_zcreadyes++; + if (0) { + errorpath: + if (mb->m_next != NULL) { + m_freem(mb->m_next); + mb->m_next = 0; + } + vrele(vp); + goto normalpath; + } + + } else { + normalpath: + nfs_serv_zcreadno++; + + /* + * Generate the mbuf list with the uio_iov ref. to it. + */ + i = 0; + m = m2 = mb; + while (left > 0) { + siz = min(M_TRAILINGSPACE(m), left); + if (siz > 0) { + left -= siz; + i++; + } + if (left > 0) { + MGET(m, M_WAIT, MT_DATA); + MCLGET(m, M_WAIT); + m->m_len = 0; + m2->m_next = m; + m2 = m; + } + } + MALLOC(iv, struct iovec *, i * sizeof (struct iovec), + M_TEMP, M_WAITOK); + uiop->uio_iov = iv2 = iv; + m = mb; + left = len; + i = 0; + while (left > 0) { + if (m == NULL) + panic("nfsrv_read iov"); + siz = min(M_TRAILINGSPACE(m), left); + if (siz > 0) { + iv->iov_base = mtod(m, caddr_t) + m->m_len; + iv->iov_len = siz; + m->m_len += siz; + left -= siz; + iv++; + i++; + } + m = m->m_next; } - m = m->m_next; + uiop->uio_iovcnt = i; + uiop->uio_offset = off; + uiop->uio_resid = len; + uiop->uio_rw = UIO_READ; + uiop->uio_segflg = UIO_SYSSPACE; + error = VOP_READ(vp, uiop, IO_NODELOCKED | ioflag, cred); + off = uiop->uio_offset; + nh->nh_nextr = off; + FREE((caddr_t)iv2, M_TEMP); + } - uiop->uio_iovcnt = i; - uiop->uio_offset = off; - uiop->uio_resid = len; - uiop->uio_rw = UIO_READ; - uiop->uio_segflg = UIO_SYSSPACE; - error = VOP_READ(vp, uiop, IO_NODELOCKED | ioflag, cred); - off = uiop->uio_offset; - nh->nh_nextr = off; - FREE((caddr_t)iv2, M_TEMP); + if (error || (getret = VOP_GETATTR(vp, vap, cred, procp))) { if (!error) error = getret; Index: nfs/nfs_socket.c =================================================================== RCS file: /home/ncvs/src/sys/nfs/nfs_socket.c,v retrieving revision 1.60.2.1 diff -u -r1.60.2.1 nfs_socket.c --- nfs/nfs_socket.c 2000/03/27 21:39:53 1.60.2.1 +++ nfs/nfs_socket.c 2001/05/01 20:46:27 @@ -1450,7 +1450,7 @@ ((nmp->nm_flag & NFSMNT_DUMBTIMR) || (rep->r_flags & R_SENT) || nmp->nm_sent < nmp->nm_cwnd) && - (m = m_copym(rep->r_mreq, 0, M_COPYALL, M_DONTWAIT))){ + (m = m_dup(rep->r_mreq, M_DONTWAIT))){ if ((nmp->nm_flag & NFSMNT_NOCONN) == 0) error = (*so->so_proto->pr_usrreqs->pru_send) (so, 0, m, (struct sockaddr *)0, Index: nfs/nfs_subs.c =================================================================== RCS file: /home/ncvs/src/sys/nfs/nfs_subs.c,v retrieving revision 1.90.2.1 diff -u -r1.90.2.1 nfs_subs.c --- nfs/nfs_subs.c 2000/10/28 16:27:27 1.90.2.1 +++ nfs/nfs_subs.c 2001/05/18 14:58:25 @@ -45,6 +45,7 @@ #include #include #include +#include #include #include #include @@ -75,6 +76,8 @@ #include +#include + /* * Data items converted to xdr at startup, since they are constant * This is kinda hokey, but may save a little time doing byte swaps @@ -776,6 +779,197 @@ } /* + * copies mbuf chain to the uio scatter/gather list, moving pages if possible + */ + + +static int nfs_client_zcread = 1; +SYSCTL_DECL(_vfs_nfs); +SYSCTL_INT(_vfs_nfs, OID_AUTO, client_zcread, CTLFLAG_RW, &nfs_client_zcread, 1, ""); + +int nfsm_zmbuftouio __P((struct buf *bp, struct mbuf **, struct uio *, int, caddr_t *)); + +#define STAT_INC(W,X) (W.X)++ +struct znfs_stats { + int mapin; + int copyin; + int cantmap_paging, cantmap_busy, cantmap_locked, + cantmap_bogus, cantmap_chain, cantmap_toosmall, + cantmap_mbufcp, cantmap_len; +} znfs_stats; + +#include +#include +extern vm_page_t bogus_page; + +int +nfsm_zmbuftouio(bp, mrep, uiop, siz, dpos) + struct buf *bp; /* struct buf we are copying to */ + struct mbuf **mrep; /* start of mbuf chain */ + register struct uio *uiop; /* uio struct */ + int siz; /* how much data to copy */ + caddr_t *dpos; /* pointer into mbuf chain to copy */ +{ + register char *mbufcp; + register int len, total; + register struct mbuf *mp; + long rem; + int error = 0, npages = 0; + int ok, s, i, busy = bp->b_pages[0]->busy; + vm_object_t object = bp->b_vp->v_object; + vm_page_t pages[16]; + + mp = *mrep; + mbufcp = *dpos; + len = mtod(mp, caddr_t)+mp->m_len-mbufcp; + rem = nfsm_rndup(siz)-siz; + + s = splvm(); + if (nfs_client_zcread == 0) + goto cantmap; + + if (siz < PAGE_SIZE) { + STAT_INC(znfs_stats, cantmap_toosmall); + goto cantmap; + } + + /* + * oddly enough, len will be 0 when we start the ball rolling + * because the rpc code will have plucked the nfs goop off the + * front of the mbuf chain. Make sure this is so + */ + + if (len != 0) { + STAT_INC(znfs_stats, cantmap_len); + } + /* + * walk the mbuf chain, gathering up M_EXT mbufs & deciding if + * we can do this easily. In the future, we should allow for + * the last mbuf in the chain to be < PAGE_SIZE + */ + total = 0; + ok = 1; + npages = 0; + + while (mp && (total < siz) && ok) { + len = 0; + while (len == 0) { + mp = mp->m_next; + if (mp == NULL) + return (EBADRPC); + mbufcp = mtod(mp, caddr_t); + len = mp->m_len; + } + total += len; + ok = mbufcp && ((len == PAGE_SIZE ) && + (((vm_offset_t)mbufcp & PAGE_MASK) == 0)); + + if (ok) + pages[npages++] = + PHYS_TO_VM_PAGE(pmap_extract(kernel_pmap, + (vm_offset_t)mbufcp)); + } + if (!ok) { + STAT_INC(znfs_stats, cantmap_chain); + if ((vm_offset_t)mbufcp & PAGE_MASK) + STAT_INC(znfs_stats, cantmap_mbufcp); + if (len != PAGE_SIZE) + STAT_INC(znfs_stats, cantmap_len); + goto cantmap; + } + /* now we know that we have an mbuf chain with page-sized, + page-aligned, ext mbufs. Go for it !! */ + + if (bp->b_flags & B_PAGING) { + /* + * could map, but need to do LOTS more. + * (user pmap needs tweaking!) XXX + */ + STAT_INC(znfs_stats, cantmap_paging); + goto cantmap; + } + for (i=0 ; ib_pages[i]; + if (m == bogus_page) { + STAT_INC(znfs_stats, cantmap_bogus); + goto cantmap; + } +#if !defined(MAX_PERF) + if (m->busy != busy) + panic("busy count mismatch"); +#endif + if ((m->flags & PG_WANTED) || (m->wire_count > 1) || + (m->busy > 1)) { + STAT_INC(znfs_stats, cantmap_busy); + goto cantmap; + } + } + + STAT_INC(znfs_stats, mapin); + + /* + * disassociate existing pages from buf (still splvm) + */ + pmap_qremove((vm_offset_t)bp->b_data, bp->b_npages); + for (i=0 ; ib_pages[i]; + + vm_page_busy(pages[i]); + vm_page_remove(pages[i]); /* remove page from the trapeze object */ + + pages[i]->pindex = m->pindex; /* remember pindex */ + + if (busy) + vm_page_io_finish(m); + vm_page_unwire(m, 0); + vm_page_busy(m); + /* + * XXX put this back + * when mmap (B_PAGING) is supported + */ +/* vm_page_protect(m, VM_PROT_NONE); */ + vm_page_free(m); + } + + /* + * map new pages into buf (still splvm); don't assumes pages were + * vm_page_remove()ed earlier. + */ + for (i=0 ; ipindex); + vm_page_flag_clear(m, PG_ZERO); + vm_page_wire(m); + if (busy) + vm_page_io_start(m); + + bp->b_pages[i] = m; + } + + pmap_qenter((vm_offset_t)bp->b_data, bp->b_pages, bp->b_npages); + splx(s); + + uiop->uio_resid = 0; + + /* + * XXX we should really fiddle with the uio & advance the + * pointers into the mbuf chain. The only thing we need to do + * is to clear the uiop->uio_resid; this needs to be done to prevent + * doio() from seeing what we did as a short read with no error + * and zero-filling the file. + */ + + return error; + + + /* NOTREACHED */ +cantmap: + splx(s); + return nfsm_mbuftouio(mrep, uiop, siz, dpos); +} + +/* * copies mbuf chain to the uio scatter/gather list */ int @@ -850,6 +1044,48 @@ return (error); } +static int +znfsm_uiotombuf(struct uio *uiop, struct mbuf **mq, int siz, caddr_t *bpos) +{ + register struct mbuf *mp, *mp2; + register int left; + int uiosiz, rem; + char *cp; + + rem = nfsm_rndup(siz)-siz; + uiosiz = uiop->uio_iov->iov_len; + if (uiosiz > siz) + uiosiz = siz; + mp2 = *mq; + mp = emb_get(uiop->uio_iov->iov_base, uiosiz, NULL, 0, M_WAIT); + if (mp == NULL) + return 1; + mp2->m_next = mp; + uiop->uio_iov->iov_base += uiosiz; + uiop->uio_iov->iov_len -= uiosiz; + uiop->uio_offset += uiosiz; + uiop->uio_resid -= uiosiz; + + while(mp->m_next != NULL) { + mp = mp->m_next; + } + if (rem > 0) { + mp2 = mp; + MGET(mp, M_WAIT, MT_DATA); + mp->m_len = 0; + mp2->m_next = mp; + cp = mtod(mp, caddr_t)+mp->m_len; + for (left = 0; left < rem; left++) + *cp++ = '\0'; + mp->m_len += rem; + *bpos = cp; + } else + *bpos = mtod(mp, caddr_t)+mp->m_len; + *mq = mp; + return (0); +} + +int nfswritehack = 1; /* * copies a uio scatter/gather list to an mbuf chain. * NOTE: can ony handle iovcnt == 1 @@ -876,6 +1112,20 @@ clflg = 1; else clflg = 0; + + if (nfswritehack && clflg && uiop->uio_segflg == UIO_SYSSPACE) { +/*printf("BEFORE: size = %d, bpos = %p, rem = %d, offset = %d, resid = %d\n", siz, bpos, + nfsm_rndup(siz)-siz, uiop->uio_offset, uiop->uio_resid);*/ + if(nfswritehack==2) goto normal; + if (0 == (znfsm_uiotombuf(uiop, mq, siz, bpos))) + { +/*if(nfswritehack) printf("AFTER: bpos = %p, iov_base = %p, iov_len = %d, offset = %d, resid = %d\n", + bpos, uiop->uio_iov->iov_base, uiop->uio_iov->iov_len, uiop->uio_offset,uiop->uio_resid );*/ + + return (0); + } + } +normal: rem = nfsm_rndup(siz)-siz; mp = mp2 = *mq; while (siz > 0) { @@ -931,6 +1181,8 @@ } else *bpos = mtod(mp, caddr_t)+mp->m_len; *mq = mp; +/*if(nfswritehack) printf("AFTER: bpos = %p, iov_base = %p, iov_len = %d, offset = %d, resid = %d\n", + bpos, uiop->uio_iov->iov_base, uiop->uio_iov->iov_len, uiop->uio_offset,uiop->uio_resid );*/ return (0); } Index: nfs/nfs_vnops.c =================================================================== RCS file: /home/ncvs/src/sys/nfs/nfs_vnops.c,v retrieving revision 1.150.2.2 diff -u -r1.150.2.2 nfs_vnops.c --- nfs/nfs_vnops.c 2001/03/02 16:45:12 1.150.2.2 +++ nfs/nfs_vnops.c 2001/05/18 14:50:09 @@ -1061,6 +1061,79 @@ * nfs read rpc call * Ditto above */ +int nfs_zreadrpc __P((struct buf *, struct vnode *, struct uio *, struct ucred *)); +int nfsm_zmbuftouio __P((struct buf *bp, struct mbuf **, struct uio *, int, caddr_t *)); + +int +nfs_zreadrpc(bp, vp, uiop, cred) + struct buf *bp; + register struct vnode *vp; + struct uio *uiop; + struct ucred *cred; +{ + register u_int32_t *tl; + register caddr_t cp; + register int32_t t1, t2; + caddr_t bpos, dpos, cp2; + struct mbuf *mreq, *mrep, *md, *mb, *mb2; + struct nfsmount *nmp; + int error = 0, len, retlen, tsiz, eof, attrflag; + int v3 = NFS_ISV3(vp); + +#ifndef nolint + eof = 0; +#endif + nmp = VFSTONFS(vp->v_mount); + tsiz = uiop->uio_resid; + if (uiop->uio_offset + tsiz > nmp->nm_maxfilesize) + return (EFBIG); + while (tsiz > 0) { + nfsstats.rpccnt[NFSPROC_READ]++; + len = (tsiz > nmp->nm_rsize) ? nmp->nm_rsize : tsiz; + nfsm_reqhead(vp, NFSPROC_READ, NFSX_FH(v3) + NFSX_UNSIGNED * 3); + nfsm_fhtom(vp, v3); + nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED * 3); + if (v3) { + txdr_hyper(uiop->uio_offset, tl); + *(tl + 2) = txdr_unsigned(len); + } else { + *tl++ = txdr_unsigned(uiop->uio_offset); + *tl++ = txdr_unsigned(len); + *tl = 0; + } + nfsm_request(vp, NFSPROC_READ, uiop->uio_procp, cred); + if (v3) { + nfsm_postop_attr(vp, attrflag); + if (error) { + m_freem(mrep); + goto nfsmout; + } + nfsm_dissect(tl, u_int32_t *, 2 * NFSX_UNSIGNED); + eof = fxdr_unsigned(int, *(tl + 1)); + } else + nfsm_loadattr(vp, (struct vattr *)0); + nfsm_strsiz(retlen, nmp->nm_rsize); + if ((retlen) > 0 && (t1 = + nfsm_zmbuftouio(bp, &md, uiop, retlen, &dpos)) != 0) { + error = t1; + m_freem(mrep); + goto nfsmout; + } + m_freem(mrep); + tsiz -= retlen; + if (v3) { + if (eof || retlen == 0) + tsiz = 0; + } else if (retlen < len) + tsiz = 0; + } +nfsmout: + return (error); +} +/* + * nfs read rpc call + * Ditto above + */ int nfs_readrpc(vp, uiop, cred) register struct vnode *vp; Index: nfs/nfsproto.h =================================================================== RCS file: /home/ncvs/src/sys/nfs/nfsproto.h,v retrieving revision 1.7 diff -u -r1.7 nfsproto.h --- nfs/nfsproto.h 1999/08/28 00:50:03 1.7 +++ nfs/nfsproto.h 2001/05/01 20:38:46 @@ -56,7 +56,7 @@ #define NFS_VER2 2 #define NFS_VER3 3 #define NFS_V2MAXDATA 8192 -#define NFS_MAXDGRAMDATA 16384 +#define NFS_MAXDGRAMDATA 32768 #define NFS_MAXDATA 32768 #define NFS_MAXPATHLEN 1024 #define NFS_MAXNAMLEN 255 Index: pci/if_ti.c =================================================================== RCS file: /home/ncvs/src/sys/pci/if_ti.c,v retrieving revision 1.25.2.7 diff -u -r1.25.2.7 if_ti.c --- pci/if_ti.c 2000/08/24 00:07:58 1.25.2.7 +++ pci/if_ti.c 2001/05/17 15:26:04 @@ -88,6 +88,8 @@ #include #include #include +/*#include */ /* XXX KDM */ +#include /* XXX KDM */ #include #include @@ -115,32 +117,48 @@ #include #include +/* #define PRIVATE_JUMBOS */ + +#if !defined(PRIVATE_JUMBOS) +#include +#endif /* !PRIVATE_JUMBOS */ +#include /* for vfindev, vgone */ + #include #include +#include #include #include #include + +#define TI_CSUM_FEATURES (CSUM_IP | CSUM_TCP | CSUM_UDP | CSUM_IP_FRAGS) +#define TI_JUMBO_HDRSPLIT + /* - * Temporarily disable the checksum offload support for now. - * Tests with ftp.freesoftware.com show that after about 12 hours, - * the firmware will begin calculating completely bogus TX checksums - * and refuse to stop until the interface is reset. Unfortunately, - * there isn't enough time to fully debug this before the 4.1 - * release, so this will need to stay off for now. + * We can only turn on header splitting if we're using extended receive + * BDs. */ -#ifdef notdef -#define TI_CSUM_FEATURES (CSUM_IP | CSUM_TCP | CSUM_UDP | CSUM_IP_FRAGS) -#else -#define TI_CSUM_FEATURES 0 -#endif +#if defined(TI_JUMBO_HDRSPLIT) && defined(PRIVATE_JUMBOS) +#error "options TI_JUMBO_HDRSPLIT and PRIVATE_JUMBOS are mutually exclusive" +#endif /* TI_JUMBO_HDRSPLIT && TI_JUMBO_HDRSPLIT */ + #if !defined(lint) static const char rcsid[] = - "$FreeBSD: src/sys/pci/if_ti.c,v 1.25.2.7 2000/08/24 00:07:58 wpaul Exp $"; + "$FreeBSD: src/sys/pci/if_ti.c,v 1.25 2000/01/18 00:26:29 wpaul Exp $"; #endif +struct ti_softc *tis[8]; + +typedef enum { + TI_SWAP_HTON, + TI_SWAP_NTOH +} ti_swap_type; + + + /* * Various supported device vendors/types and their names. */ @@ -163,6 +181,30 @@ { 0, 0, NULL } }; + +#define TI_CDEV_MAJOR 149 + +static d_open_t ti_open; +static d_close_t ti_close; +static d_ioctl_t ti_ioctl2; + +static struct cdevsw ti_cdevsw = { + /* open */ ti_open, + /* close */ ti_close, + /* read */ NULL, + /* write */ NULL, + /* ioctl */ ti_ioctl2, + /* poll */ seltrue, + /* mmap */ nommap, + /* strategy */ nostrategy, + /* name */ "ti", + /* maj */ TI_CDEV_MAJOR, + /* dump */ nodump, + /* psize */ nopsize, + /* flags */ 0, + /* bmaj */ -1 +}; + static int ti_probe __P((device_t)); static int ti_attach __P((device_t)); static int ti_detach __P((device_t)); @@ -195,15 +237,23 @@ static void ti_mem __P((struct ti_softc *, u_int32_t, u_int32_t, caddr_t)); +static int ti_copy_mem __P((struct ti_softc *, u_int32_t, + u_int32_t, caddr_t, int, int)); +static int ti_copy_scratch __P((struct ti_softc *, u_int32_t, + u_int32_t, caddr_t, int, int, int)); +static int ti_bcopy_swap __P((const void *, void *, size_t, + ti_swap_type)); static void ti_loadfw __P((struct ti_softc *)); static void ti_cmd __P((struct ti_softc *, struct ti_cmd_desc *)); static void ti_cmd_ext __P((struct ti_softc *, struct ti_cmd_desc *, caddr_t, int)); static void ti_handle_events __P((struct ti_softc *)); +#ifdef PRIVATE_JUMBOS static int ti_alloc_jumbo_mem __P((struct ti_softc *)); static void *ti_jalloc __P((struct ti_softc *)); static void ti_jfree __P((caddr_t, u_int)); static void ti_jref __P((caddr_t, u_int)); +#endif /* PRIVATE_JUMBOS */ static int ti_newbuf_std __P((struct ti_softc *, int, struct mbuf *)); static int ti_newbuf_mini __P((struct ti_softc *, int, struct mbuf *)); static int ti_newbuf_jumbo __P((struct ti_softc *, int, struct mbuf *)); @@ -239,6 +289,21 @@ DRIVER_MODULE(if_ti, pci, ti_driver, ti_devclass, 0, 0); + +/* List of Tigon softcs */ +static STAILQ_HEAD(ti_softc_list, ti_softc) ti_sc_list; + +static struct ti_softc * +ti_lookup_softc(int unit) +{ + struct ti_softc *sc; + for (sc = STAILQ_FIRST(&ti_sc_list); sc != NULL; + sc = STAILQ_NEXT(sc, ti_links)) + if (sc->ti_unit == unit) + return(sc); + return(NULL); +} + /* * Send an instruction or address to the EEPROM, check for ACK. */ @@ -419,6 +484,341 @@ return; } +static int +ti_copy_mem(sc, tigon_addr, len, buf, useraddr, readdata) + struct ti_softc *sc; + u_int32_t tigon_addr, len; + caddr_t buf; + int useraddr, readdata; +{ + int segptr, segsize, cnt; + caddr_t ptr; + int s; + u_int32_t origwin; + u_int8_t tmparray[TI_WINLEN], tmparray2[TI_WINLEN]; + int resid, segresid; + int first_pass; + + /* + * At the moment, we don't handle non-aligned cases, we just bail. + * If this proves to be a problem, it will be fixed. + */ + if ((readdata == 0) + && (tigon_addr & 0x3)) { + printf("ti%d: ti_copy_mem: tigon address %#x isn't " + "word-aligned\n", sc->ti_unit, tigon_addr); + printf("ti%d: ti_copy_mem: unaligned writes aren't yet " + "supported\n", sc->ti_unit); + return(EINVAL); + } + + segptr = tigon_addr & ~0x3; + segresid = tigon_addr - segptr; + + /* + * This is the non-aligned amount left over that we'll need to + * copy. + */ + resid = len & 0x3; + + /* Add in the left over amount at the front of the buffer */ + resid += segresid; + + cnt = len & ~0x3; + /* + * If resid + segresid is >= 4, add multiples of 4 to the count and + * decrease the residual by that much. + */ + cnt += resid & ~0x3; + resid -= resid & ~0x3; + + ptr = buf; + + first_pass = 1; + + /* + * Make sure we aren't interrupted while we're changing the window + * pointer. + */ + s = splimp(); + + /* + * Save the old window base value. + */ + origwin = CSR_READ_4(sc, TI_WINBASE); + + while(cnt) { + bus_size_t ti_offset; + + if (cnt < TI_WINLEN) + segsize = cnt; + else + segsize = TI_WINLEN - (segptr % TI_WINLEN); + CSR_WRITE_4(sc, TI_WINBASE, (segptr & ~(TI_WINLEN - 1))); + + ti_offset = TI_WINDOW + (segptr & (TI_WINLEN -1)); + + if (readdata) { + + bus_space_read_region_4(sc->ti_btag, + sc->ti_bhandle, ti_offset, + (u_int32_t *)tmparray, + segsize >> 2); + if (useraddr) { + /* + * Yeah, this is a little on the kludgy + * side, but at least this code is only + * used for debugging. + */ + ti_bcopy_swap(tmparray, tmparray2, segsize, + TI_SWAP_NTOH); + + if (first_pass) { + copyout(&tmparray2[segresid], ptr, + segsize - segresid); + first_pass = 0; + } else + copyout(tmparray2, ptr, segsize); + } else { + if (first_pass) { + + ti_bcopy_swap(tmparray, tmparray2, + segsize, TI_SWAP_NTOH); + bcopy(&tmparray2[segresid], ptr, + segsize - segresid); + first_pass = 0; + } else + ti_bcopy_swap(tmparray, ptr, segsize, + TI_SWAP_NTOH); + } + + } else { + if (useraddr) { + copyin(ptr, tmparray2, segsize); + ti_bcopy_swap(tmparray2, tmparray, segsize, + TI_SWAP_HTON); + } else + ti_bcopy_swap(ptr, tmparray, segsize, + TI_SWAP_HTON); + + bus_space_write_region_4(sc->ti_btag, + sc->ti_bhandle, ti_offset, + (u_int32_t *)tmparray, + segsize >> 2); + } + segptr += segsize; + ptr += segsize; + cnt -= segsize; + } + + /* + * Handle leftover, non-word-aligned bytes. + */ + if (resid != 0) { + u_int32_t tmpval, tmpval2; + bus_size_t ti_offset; + + /* + * Set the segment pointer. + */ + CSR_WRITE_4(sc, TI_WINBASE, (segptr & ~(TI_WINLEN - 1))); + + ti_offset = TI_WINDOW + (segptr & (TI_WINLEN - 1)); + + /* + * First, grab whatever is in our source/destination. + * We'll obviously need this for reads, but also for + * writes, since we'll be doing read/modify/write. + */ + bus_space_read_region_4(sc->ti_btag, sc->ti_bhandle, + ti_offset, &tmpval, 1); + + /* + * Next, translate this from little-endian to big-endian + * (at least on i386 boxes). + */ + tmpval2 = ntohl(tmpval); + + if (readdata) { + /* + * If we're reading, just copy the leftover number + * of bytes from the host byte order buffer to + * the user's buffer. + */ + if (useraddr) + copyout(&tmpval2, ptr, resid); + else + bcopy(&tmpval2, ptr, resid); + } else { + /* + * If we're writing, first copy the bytes to be + * written into the network byte order buffer, + * leaving the rest of the buffer with whatever was + * originally in there. Then, swap the bytes + * around into host order and write them out. + * + * XXX KDM the read side of this has been verified + * to work, but the write side of it has not been + * verified. So user beware. + */ + if (useraddr) + copyin(ptr, &tmpval2, resid); + else + bcopy(ptr, &tmpval2, resid); + + tmpval = htonl(tmpval2); + + bus_space_write_region_4(sc->ti_btag, sc->ti_bhandle, + ti_offset, &tmpval, 1); + } + } + + CSR_WRITE_4(sc, TI_WINBASE, origwin); + + splx(s); + + return(0); +} + +static int +ti_copy_scratch(sc, tigon_addr, len, buf, useraddr, readdata, cpu) + struct ti_softc *sc; + u_int32_t tigon_addr, len; + caddr_t buf; + int useraddr, readdata; + int cpu; +{ + u_int32_t segptr; + int s, cnt; + u_int32_t tmpval, tmpval2; + caddr_t ptr; + + /* + * At the moment, we don't handle non-aligned cases, we just bail. + * If this proves to be a problem, it will be fixed. + */ + if (tigon_addr & 0x3) { + printf("ti%d: ti_copy_scratch: tigon address %#x isn't " + "word-aligned\n", sc->ti_unit, tigon_addr); + return(EINVAL); + } + + if (len & 0x3) { + printf("ti%d: ti_copy_scratch: transfer length %d isn't " + "word-aligned\n", sc->ti_unit, len); + return(EINVAL); + } + + segptr = tigon_addr; + cnt = len; + ptr = buf; + + s = splimp(); + + while (cnt) { + CSR_WRITE_4(sc, CPU_REG(TI_SRAM_ADDR, cpu), segptr); + + if (readdata) { + tmpval2 = CSR_READ_4(sc, CPU_REG(TI_SRAM_DATA, cpu)); + + tmpval = ntohl(tmpval2); + + /* + * Note: I've used this debugging interface + * extensively with Alteon's 12.3.15 firmware, + * compiled with GCC 2.7.2.1 and binutils 2.9.1. + * + * When you compile the firmware without + * optimization, which is necessary sometimes in + * order to properly step through it, you sometimes + * read out a bogus value of 0xc0017c instead of + * whatever was supposed to be in that scratchpad + * location. That value is on the stack somewhere, + * but I've never been able to figure out what was + * causing the problem. + * + * The address seems to pop up in random places, + * often not in the same place on two subsequent + * reads. + * + * In any case, the underlying data doesn't seem + * to be affected, just the value read out. + * + * KDM, 3/7/2000 + */ + + if (tmpval2 == 0xc0017c) + printf("ti%d: found 0xc0017c at %#x " + "(tmpval2)\n", sc->ti_unit, segptr); + + if (tmpval == 0xc0017c) + printf("ti%d: found 0xc0017c at %#x " + "(tmpval)\n", sc->ti_unit, segptr); + + if (useraddr) + copyout(&tmpval, ptr, 4); + else + bcopy(&tmpval, ptr, 4); + } else { + if (useraddr) + copyin(ptr, &tmpval2, 4); + else + bcopy(ptr, &tmpval2, 4); + + tmpval = htonl(tmpval2); + + CSR_WRITE_4(sc, CPU_REG(TI_SRAM_DATA, cpu), tmpval); + } + + cnt -= 4; + segptr += 4; + ptr += 4; + } + + splx(s); + + return(0); +} + +static int +ti_bcopy_swap(src, dst, len, swap_type) + const void *src; + void *dst; + size_t len; + ti_swap_type swap_type; +{ + const u_int8_t *tmpsrc; + u_int8_t *tmpdst; + size_t tmplen; + + if (len & 0x3) { + printf("ti_bcopy_swap: length %d isn't 32-bit aligned\n", + len); + return(-1); + } + + tmpsrc = src; + tmpdst = dst; + tmplen = len; + + while (tmplen) { + if (swap_type == TI_SWAP_NTOH) + *(u_int32_t *)tmpdst = + ntohl(*(const u_int32_t *)tmpsrc); + else + *(u_int32_t *)tmpdst = + htonl(*(const u_int32_t *)tmpsrc); + + tmpsrc += 4; + tmpdst += 4; + tmplen -= 4; + } + + return(0); +} + + + /* * Load firmware image into the NIC. Check that the firmware revision * is acceptable and see if we want the firmware for the Tigon 1 or @@ -584,6 +984,8 @@ return; } +#ifdef PRIVATE_JUMBOS + /* * Memory management for the jumbo receive ring is a pain in the * butt. We need to allocate at least 9018 bytes of space per frame, @@ -768,6 +1170,7 @@ return; } +#endif /* PRIVATE_JUMBOS */ /* * Intialize a standard receive ring descriptor. @@ -856,6 +1259,8 @@ return(0); } +#ifdef PRIVATE_JUMBOS + /* * Initialize a jumbo receive ring descriptor. This allocates * a jumbo buffer from the pool managed internally by the driver. @@ -916,6 +1321,161 @@ return(0); } +#else + +#if (PAGE_SIZE == 4096) +#define NPAYLOAD 2 +#else +#define NPAYLOAD 1 +#endif + +#define TCP_HDR_LEN (52 + sizeof(struct ether_header)) +#define UDP_HDR_LEN (28 + sizeof(struct ether_header)) +#define NFS_HDR_LEN (UDP_HDR_LEN) +int HDR_LEN = TCP_HDR_LEN; + + + /* + * Initialize a jumbo receive ring descriptor. This allocates + * a jumbo buffer from the pool managed internally by the driver. + */ +static int +ti_newbuf_jumbo(sc, idx, m_old) + struct ti_softc *sc; + int idx; + struct mbuf *m_old; +{ + struct mbuf *cur, *m_new = NULL; + struct mbuf *m[3] = {NULL, NULL, NULL}; + struct ti_rx_desc_ext *r; + vm_page_t frame; + /* 1 extra buf to make nobufs easy*/ + caddr_t buf[3] = {NULL, NULL, NULL}; + int i, s; + + if (m_old != NULL) { + m_new = m_old; + cur = m_old->m_next; + for(i = 0; i <= NPAYLOAD; i++){ + m[i] = cur; + cur = cur->m_next; + } + + } else { + +/* + * splhigh to avoid splimp/splx in mbuf code & splvm/splx in jumbo_pg_alloc + */ + s = splhigh(); + /* Allocate the mbufs. */ + MGETHDR(m_new, M_DONTWAIT, MT_DATA); + if (m_new == NULL) { + printf("ti%d: mbuf allocation failed " + "-- packet dropped!\n", sc->ti_unit); + goto nobufs; + } + MGET(m[NPAYLOAD], M_DONTWAIT, MT_DATA); + if (m[NPAYLOAD] == NULL) { + printf("ti%d: cluster mbuf allocation failed " + "-- packet dropped!\n", sc->ti_unit); + goto nobufs; + } + MCLGET(m[NPAYLOAD], M_DONTWAIT); + if ((m[NPAYLOAD]->m_flags & M_EXT) == 0) { + printf("ti%d: mbuf allocation failed " + "-- packet dropped!\n", sc->ti_unit); + goto nobufs; + } + m[NPAYLOAD]->m_len = MCLBYTES; + + for(i = 0; i < NPAYLOAD; i++){ + MGET(m[i], M_DONTWAIT, MT_DATA); + if (m[i] == NULL) { + printf("ti%d: mbuf allocation failed " + "-- packet dropped!\n", sc->ti_unit); + goto nobufs; + } + if(!(frame = jumbo_pg_alloc())){ + printf("ti%d: buffer allocation failed " + "-- packet dropped!", sc->ti_unit); + printf(" index %d page %d\n", idx, i); + goto nobufs; + } + buf[i] = jumbo_phys_to_kva(VM_PAGE_TO_PHYS(frame)); + } + splx(s); + for(i = 0; i < NPAYLOAD; i++){ + /* Attach the buffer to the mbuf. */ + m[i]->m_data = m[i]->m_ext.ext_buf = (void *)buf[i]; + m[i]->m_flags |= M_EXT; + m[i]->m_ext.ext_size = m[i]->m_len = PAGE_SIZE; + m[i]->m_ext.ext_free = jumbo_freem; + m[i]->m_ext.ext_ref = jumbo_ref; + m[i]->m_next = m[i+1]; + } + /* link the buffers to the header */ + m_new->m_next = m[0]; + m_new->m_data += ETHER_ALIGN; +#ifdef TI_JUMBO_HDRSPLIT + m_new->m_len = MHLEN - ETHER_ALIGN;; +#else /* TI_JUMBO_HDRSPLIT */ + m_new->m_len = HDR_LEN; +#endif /* TI_JUMBO_HDRSPLIT */ + m_new->m_pkthdr.len = NPAYLOAD * PAGE_SIZE + m_new->m_len; + + } + + /* Set up the descriptor. */ + r = &sc->ti_rdata->ti_rx_jumbo_ring[idx]; + sc->ti_cdata.ti_rx_jumbo_chain[idx] = m_new; + + TI_HOSTADDR(r->ti_addr0) = vtophys(mtod(m_new, caddr_t)); + r->ti_len0 = m_new->m_len; + + TI_HOSTADDR(r->ti_addr1) = vtophys(mtod(m[0], caddr_t)); + r->ti_len1 = PAGE_SIZE; + + TI_HOSTADDR(r->ti_addr2) = vtophys(mtod(m[1], caddr_t)); + r->ti_len2 = m[1]->m_ext.ext_size; /* could be PAGE_SIZE or MCLBYTES */ + + if (PAGE_SIZE == 4096) { + TI_HOSTADDR(r->ti_addr3) = vtophys(mtod(m[2], caddr_t)); + r->ti_len3 = MCLBYTES; + } else { + r->ti_len3 = 0; + } + r->ti_type = TI_BDTYPE_RECV_JUMBO_BD; + + r->ti_flags = TI_BDFLAG_JUMBO_RING|TI_RCB_FLAG_USE_EXT_RX_BD; + if (sc->arpcom.ac_if.if_hwassist) + r->ti_flags |= TI_BDFLAG_TCP_UDP_CKSUM | TI_BDFLAG_IP_CKSUM; + r->ti_idx = idx; + + return(0); + + nobufs: +/* + * Warning! : + * This can only be called before the mbufs are strung together. + * If the mbufs are strung together, m_freem() will free the chain, + * so that the later mbufs will be freed multiple times. + */ + splx(s); + if(m_new) + m_freem(m_new); + + for(i = 0; i < 3; i++){ + if(m[i]) + m_freem(m[i]); + if(buf[i]) + jumbo_pg_free((vm_offset_t)buf[i]); + } + return ENOBUFS; +} +#endif + + + /* * The standard receive ring has 512 entries in it. At 2K per mbuf cluster, * that's 1MB or memory, which is a lot. For now, we fill only the first @@ -962,7 +1522,22 @@ register int i; struct ti_cmd_desc cmd; + /* + * It seems that you need a sort of window between the number of + * jumbo buffers allocated and the number stuck into the receive + * ring. If the number of buffers allocated to the receive ring is + * too high, the driver will end up running out of new buffers to + * put in because the old buffers aren't getting freed fast enough. + * Yes, I know this explanation doesn't make a whole lot of sense, + * but I don't feel like taking the time to think it through + * further. + * KDM, 8/12/99 + */ +#ifdef PRIVATE_JUMBOS + for (i = 0; i < (TI_JSLOTS - 40); i++) { +#else for (i = 0; i < TI_JUMBO_RX_RING_CNT; i++) { +#endif if (ti_newbuf_jumbo(sc, i, NULL) == ENOBUFS) return(ENOBUFS); }; @@ -1213,6 +1788,7 @@ { u_int32_t cacheline; u_int32_t pci_writemax = 0; + u_int32_t hdrsplit; /* Initialize link to down state. */ sc->ti_linkstat = TI_EV_CODE_LINK_DOWN; @@ -1313,16 +1889,23 @@ /* This sets the min dma param all the way up (0xff). */ TI_SETBIT(sc, TI_PCI_STATE, TI_PCISTATE_MINDMA); +#ifdef TI_JUMBO_HDRSPLIT + hdrsplit = TI_OPMODE_JUMBO_HDRSPLIT; +#else + hdrsplit = 0; +#endif + + /* Configure DMA variables. */ #if BYTE_ORDER == BIG_ENDIAN CSR_WRITE_4(sc, TI_GCR_OPMODE, TI_OPMODE_BYTESWAP_BD | TI_OPMODE_BYTESWAP_DATA | TI_OPMODE_WORDSWAP_BD | TI_OPMODE_WARN_ENB | TI_OPMODE_FATAL_ENB | - TI_OPMODE_DONT_FRAG_JUMBO); + TI_OPMODE_DONT_FRAG_JUMBO | hdrsplit); #else CSR_WRITE_4(sc, TI_GCR_OPMODE, TI_OPMODE_BYTESWAP_DATA| TI_OPMODE_WORDSWAP_BD|TI_OPMODE_DONT_FRAG_JUMBO| - TI_OPMODE_WARN_ENB|TI_OPMODE_FATAL_ENB); + TI_OPMODE_WARN_ENB|TI_OPMODE_FATAL_ENB | hdrsplit); #endif /* @@ -1422,8 +2005,15 @@ rcb = &sc->ti_rdata->ti_info.ti_jumbo_rx_rcb; TI_HOSTADDR(rcb->ti_hostaddr) = vtophys(&sc->ti_rdata->ti_rx_jumbo_ring); + +#ifdef PRIVATE_JUMBOS rcb->ti_max_len = TI_JUMBO_FRAMELEN; rcb->ti_flags = 0; +#else + rcb->ti_max_len = PAGE_SIZE; + rcb->ti_flags = TI_RCB_FLAG_USE_EXT_RX_BD; +#endif + if (sc->arpcom.ac_if.if_hwassist) rcb->ti_flags |= TI_RCB_FLAG_TCP_UDP_CKSUM | TI_RCB_FLAG_IP_CKSUM | TI_RCB_FLAG_NO_PHDR_CKSUM; @@ -1499,10 +2089,12 @@ vtophys(&sc->ti_tx_considx); /* Set up tuneables */ +#if 0 if (ifp->if_mtu > (ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN)) CSR_WRITE_4(sc, TI_GCR_RX_COAL_TICKS, (sc->ti_rx_coal_ticks / 10)); else +#endif CSR_WRITE_4(sc, TI_GCR_RX_COAL_TICKS, sc->ti_rx_coal_ticks); CSR_WRITE_4(sc, TI_GCR_TX_COAL_TICKS, sc->ti_tx_coal_ticks); CSR_WRITE_4(sc, TI_GCR_STAT_TICKS, sc->ti_stat_ticks); @@ -1543,6 +2135,40 @@ return(ENXIO); } +#ifdef KLD_MODULE +static int +log2rndup(int len) +{ + int log2size = 0, t = len; + while (t > 1) { + log2size++; + t >>= 1; + } + if (len != (1 << log2size)) + log2size++; + return log2size; +} + +static int +ti_mbuf_sanity(device_t dev) +{ + if((mbstat.m_msize != MSIZE) + || mbstat.m_mclbytes != MCLBYTES){ + device_printf(dev, "\n"); + device_printf(dev, + "This module was compiled with -DMCLSHIFT=%d -DMSIZE=%d\n", + MCLSHIFT, MSIZE); + device_printf(dev, + "The kernel was compiled with MCLSHIFT=%d, MSIZE=%d\n", + log2rndup(mbstat.m_mclbytes), (int)mbstat.m_msize); + return EINVAL; + } + return 0; + +} +#endif + + static int ti_attach(dev) device_t dev; { @@ -1554,6 +2180,16 @@ s = splimp(); +#ifdef KLD_MODULE + if(ti_mbuf_sanity(dev)){ + device_printf(dev, "Module mbuf constants do not match kernel constants!\n"); + device_printf(dev, "Rebuild the module or the kernel so they match\n"); + device_printf(dev, "\n"); + error = EINVAL; + goto fail; + } +#endif + sc = device_get_softc(dev); unit = device_get_unit(dev); bzero(sc, sizeof(struct ti_softc)); @@ -1692,6 +2328,7 @@ bzero(sc->ti_rdata, sizeof(struct ti_ring_data)); /* Try to allocate memory for jumbo buffers. */ +#ifdef PRIVATE_JUMBOS if (ti_alloc_jumbo_mem(sc)) { printf("ti%d: jumbo buffer allocation failed\n", sc->ti_unit); bus_teardown_intr(dev, sc->ti_irq, sc->ti_intrhand); @@ -1703,6 +2340,19 @@ error = ENXIO; goto fail; } +#else + if (!jumbo_vm_init()) { + printf("ti%d: VM initialization failed!\n", sc->ti_unit); + bus_teardown_intr(dev, sc->ti_irq, sc->ti_intrhand); + bus_release_resource(dev, SYS_RES_IRQ, 0, sc->ti_irq); + bus_release_resource(dev, SYS_RES_MEMORY, + TI_PCI_LOMEM, sc->ti_res); + contigfree(sc->ti_rdata, sizeof(struct ti_ring_data), + M_DEVBUF); + error = ENOMEM; + goto fail; + } +#endif /* * We really need a better way to tell a 1000baseTX card @@ -1719,12 +2369,19 @@ pci_get_device(dev) == NG_DEVICEID_GA620T) sc->ti_copper = 1; + /* Set default tuneable values. */ sc->ti_stat_ticks = 2 * TI_TICKS_PER_SEC; +#if 0 sc->ti_rx_coal_ticks = TI_TICKS_PER_SEC / 5000; +#endif + sc->ti_rx_coal_ticks = 170; sc->ti_tx_coal_ticks = TI_TICKS_PER_SEC / 500; sc->ti_rx_max_coal_bds = 64; +#if 0 sc->ti_tx_max_coal_bds = 128; +#endif + sc->ti_tx_max_coal_bds = 32; sc->ti_tx_buf_ratio = 21; /* Set up ifnet structure */ @@ -1733,6 +2390,7 @@ ifp->if_unit = sc->ti_unit; ifp->if_name = "ti"; ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; + tis[unit] = sc; ifp->if_ioctl = ti_ioctl; ifp->if_output = ether_output; ifp->if_start = ti_start; @@ -1774,13 +2432,59 @@ * Call MI attach routine. */ ether_ifattach(ifp, ETHER_BPF_SUPPORTED); + + + bpfattach(ifp, DLT_EN10MB, sizeof(struct ether_header)); + /* + * If this is the first card to be initialized, initialize the + * softc queue. + */ + if (unit == 0) + STAILQ_INIT(&ti_sc_list); + + STAILQ_INSERT_TAIL(&ti_sc_list, sc, ti_links); + + /* Register the device */ + sc->dev = make_dev(&ti_cdevsw, sc->ti_unit, UID_ROOT, GID_OPERATOR, + 0600, "ti%d", sc->ti_unit); + fail: splx(s); return(error); } +/* + * Verify that our character special device is not currently + * open. Also track down any cached vnodes & kill them before + * the module is unloaded + */ + +static int +ti_unref_special(device_t dev) +{ + struct vnode *ti_vn; + int count; + struct ti_softc *sc = sc = device_get_softc(dev); + + if(!vfinddev(sc->dev, VCHR, &ti_vn)){ + return 0; + } + + if((count = vcount(ti_vn))){ + device_printf(dev, + "%d refs to special device, denying unload\n", + count); + return count; + } + /* now we know that there's a vnode in the cache. We hunt it + down and kill it now, before unloading */ + vgone(ti_vn); + return 0; +} + + static int ti_detach(dev) device_t dev; { @@ -1788,6 +2492,9 @@ struct ifnet *ifp; int s; + if(ti_unref_special(dev)) + return EBUSY; + s = splimp(); sc = device_get_softc(dev); @@ -1800,7 +2507,11 @@ bus_release_resource(dev, SYS_RES_IRQ, 0, sc->ti_irq); bus_release_resource(dev, SYS_RES_MEMORY, TI_PCI_LOMEM, sc->ti_res); +#ifdef PRIVATE_JUMBOS contigfree(sc->ti_cdata.ti_jumbo_buf, TI_JMEM, M_DEVBUF); +#else +/* ti_free_jumbos(dev);*/ +#endif contigfree(sc->ti_rdata, sizeof(struct ti_ring_data), M_DEVBUF); ifmedia_removeall(&sc->ifmedia); @@ -1809,6 +2520,67 @@ return(0); } +#ifndef PRIVATE_JUMBOS + +/* + * If hdr_len is 0, that means that header splitting wasn't done on + * this packet for some reason. The two most likely reasons are that + * the protocol isn't a supported protocol for splitting, or this + * packet had a fragment offset that wasn't 0. + * + * The header length, if it is non-zero, will always be the length of + * the headers on the packet, but that length could be longer than the + * first mbuf. So we take the minimum of the two as the actual + * length. + */ + + +static /*__inline*/ void +ti_hdr_split(struct mbuf *top, int hdr_len, int pkt_len, int idx) +{ + int i = 0; + int lengths[4] = {0, 0, 0, 0}; + struct mbuf *m, *mp; + + if (hdr_len != 0) + top->m_len = min(hdr_len, top->m_len); + pkt_len -= top->m_len; + lengths[i++] = top->m_len; + + mp = top; + for (m = top->m_next; m && pkt_len; m = m->m_next) { + m->m_len = m->m_ext.ext_size = min(m->m_len, pkt_len); + pkt_len -= m->m_len; + lengths[i++] = m->m_len; + mp = m; + } + +#if 0 + if (hdr_len != 0) + printf("got split packet: "); + else + printf("got non-split packet: "); + + printf("%d,%d,%d,%d = %d\n", lengths[0], + lengths[1], lengths[2], lengths[3], + lengths[0] + lengths[1] + lengths[2] + + lengths[3]); +#endif + + if (pkt_len) + panic("header splitting didn't"); + + if (m) { + m_freem(m); + mp->m_next = NULL; + + } + if (mp->m_next != NULL) + panic("ti_hdr_split: last mbuf in chain should be null"); +} + +#endif + /* * Frame reception handling. This is called if there's a frame * on the receive return list. @@ -1864,6 +2636,16 @@ ti_newbuf_jumbo(sc, sc->ti_jumbo, m); continue; } +#ifdef PRIVATE_JUMBOS + m->m_len = cur_rx->ti_len; +#else /* PRIVATE_JUMBOS */ +#ifdef TI_JUMBO_HDRSPLIT + ti_hdr_split(m, TI_HOSTADDR(cur_rx->ti_addr), + cur_rx->ti_len, rxidx); +#else /* TI_JUMBO_HDRSPLIT */ + m_adj(m, cur_rx->ti_len - m->m_pkthdr.len); +#endif /* TI_JUMBO_HDRSPLIT */ +#endif /* PRIVATE_JUMBOS */ } else if (cur_rx->ti_flags & TI_BDFLAG_MINI_RING) { TI_INC(sc->ti_mini, TI_MINI_RX_RING_CNT); m = sc->ti_cdata.ti_rx_mini_chain[rxidx]; @@ -1878,6 +2660,7 @@ ti_newbuf_mini(sc, sc->ti_mini, m); continue; } + m->m_len = cur_rx->ti_len; } else { TI_INC(sc->ti_std, TI_STD_RX_RING_CNT); m = sc->ti_cdata.ti_rx_std_chain[rxidx]; @@ -1892,9 +2675,10 @@ ti_newbuf_std(sc, sc->ti_std, m); continue; } + m->m_len = cur_rx->ti_len; } - m->m_pkthdr.len = m->m_len = cur_rx->ti_len; + m->m_pkthdr.len = cur_rx->ti_len; ifp->if_ipackets++; eh = mtod(m, struct ether_header *); m->m_pkthdr.rcvif = ifp; @@ -1994,12 +2778,12 @@ sc = xsc; ifp = &sc->arpcom.ac_if; -#ifdef notdef +/*#ifdef notdef*/ /* Avoid this for now -- checking this register is expensive. */ /* Make sure this is really our interrupt. */ if (!(CSR_READ_4(sc, TI_MISC_HOST_CTL) & TI_MHC_INTSTATE)) return; -#endif +/*#endif*/ /* Ack interrupt and stop others from occuring. */ CSR_WRITE_4(sc, TI_MB_HOSTINTR, 1); @@ -2075,6 +2859,7 @@ else if (m_head->m_flags & M_FRAG) csum_flags |= TI_BDFLAG_IP_FRAG; } + /* * Start packing the mbufs in this chain into * the fragment pointers. Stop when we run out @@ -2230,6 +3015,10 @@ splx(s); + /* Register the device */ + sc->dev = make_dev(&ti_cdevsw, sc->ti_unit, UID_ROOT, GID_OPERATOR, + 0600, "ti%d", sc->ti_unit); + return; } @@ -2509,13 +3298,334 @@ return(error); } +static int +ti_open(dev_t dev, int flags, int fmt, struct proc *p) +{ + int unit, s; + struct ti_softc *sc; + + unit = minor(dev) & 0xff; + + sc = ti_lookup_softc(unit); + + if (sc == NULL) + return(ENODEV); + + s = splimp(); + sc->ti_flags |= TI_FLAG_DEBUGING; + splx(s); + + return(0); +} + +static int +ti_close(dev_t dev, int flag, int fmt, struct proc *p) +{ + int unit, s; + struct ti_softc *sc; + + unit = minor(dev) & 0xff; + + sc = ti_lookup_softc(unit); + + if (sc == NULL) + return(ENODEV); + + s = splimp(); + sc->ti_flags &= ~TI_FLAG_DEBUGING; + splx(s); + + return(0); +} + +/* + * This ioctl routine goes along with the Tigon character device. + */ +static int +ti_ioctl2(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) +{ + int unit, error; + struct ti_softc *sc; + + unit = minor(dev) & 0xff; + + sc = ti_lookup_softc(unit); + + if (sc == NULL) + return(ENODEV); + + error = 0; + + switch(cmd) { + case TIIOCGETSTATS: + { + struct ti_stats *outstats; + + outstats = (struct ti_stats *)addr; + + bcopy(&sc->ti_rdata->ti_info.ti_stats, outstats, + sizeof(struct ti_stats)); + break; + } + case TIIOCGETPARAMS: + { + struct ti_params *params; + + params = (struct ti_params *)addr; + + params->ti_stat_ticks = sc->ti_stat_ticks; + params->ti_rx_coal_ticks = sc->ti_rx_coal_ticks; + params->ti_tx_coal_ticks = sc->ti_tx_coal_ticks; + params->ti_rx_max_coal_bds = sc->ti_rx_max_coal_bds; + params->ti_tx_max_coal_bds = sc->ti_tx_max_coal_bds; + params->ti_tx_buf_ratio = sc->ti_tx_buf_ratio; + params->param_mask = TI_PARAM_ALL; + + error = 0; + + break; + } + case TIIOCSETPARAMS: + { + struct ti_params *params; + + params = (struct ti_params *)addr; + + if (params->param_mask & TI_PARAM_STAT_TICKS) { + sc->ti_stat_ticks = params->ti_stat_ticks; + CSR_WRITE_4(sc, TI_GCR_STAT_TICKS, sc->ti_stat_ticks); + } + + if (params->param_mask & TI_PARAM_RX_COAL_TICKS) { + sc->ti_rx_coal_ticks = params->ti_rx_coal_ticks; + CSR_WRITE_4(sc, TI_GCR_RX_COAL_TICKS, + sc->ti_rx_coal_ticks); + } + + if (params->param_mask & TI_PARAM_TX_COAL_TICKS) { + sc->ti_tx_coal_ticks = params->ti_tx_coal_ticks; + CSR_WRITE_4(sc, TI_GCR_TX_COAL_TICKS, + sc->ti_tx_coal_ticks); + } + + if (params->param_mask & TI_PARAM_RX_COAL_BDS) { + sc->ti_rx_max_coal_bds = params->ti_rx_max_coal_bds; + CSR_WRITE_4(sc, TI_GCR_RX_MAX_COAL_BD, + sc->ti_rx_max_coal_bds); + } + + if (params->param_mask & TI_PARAM_TX_COAL_BDS) { + sc->ti_tx_max_coal_bds = params->ti_tx_max_coal_bds; + CSR_WRITE_4(sc, TI_GCR_TX_MAX_COAL_BD, + sc->ti_tx_max_coal_bds); + } + + if (params->param_mask & TI_PARAM_TX_BUF_RATIO) { + sc->ti_tx_buf_ratio = params->ti_tx_buf_ratio; + CSR_WRITE_4(sc, TI_GCR_TX_BUFFER_RATIO, + sc->ti_tx_buf_ratio); + } + + error = 0; + + break; + } + case TIIOCSETTRACE: { + ti_trace_type trace_type; + + trace_type = *(ti_trace_type *)addr; + + /* + * Set tracing to whatever the user asked for. Setting + * this register to 0 should have the effect of disabling + * tracing. + */ + CSR_WRITE_4(sc, TI_GCR_NIC_TRACING, trace_type); + + error = 0; + + break; + } + case TIIOCGETTRACE: { + struct ti_trace_buf *trace_buf; + u_int32_t trace_start, cur_trace_ptr, trace_len; + + trace_buf = (struct ti_trace_buf *)addr; + + trace_start = CSR_READ_4(sc, TI_GCR_NICTRACE_START); + cur_trace_ptr = CSR_READ_4(sc, TI_GCR_NICTRACE_PTR); + trace_len = CSR_READ_4(sc, TI_GCR_NICTRACE_LEN); + + printf("ti%d: trace_start = %#x, cur_trace_ptr = %#x, " + "trace_len = %d\n", sc->ti_unit, trace_start, + cur_trace_ptr, trace_len); + printf("ti%d: trace_buf->buf_len = %d\n", sc->ti_unit, + trace_buf->buf_len); + /* XXX KDM pick up here */ + + error = ti_copy_mem(sc, trace_start, min(trace_len, + trace_buf->buf_len), + (caddr_t)trace_buf->buf, 1, 1); + + if (error == 0) { + trace_buf->fill_len = min(trace_len, + trace_buf->buf_len); + if (cur_trace_ptr < trace_start) + trace_buf->cur_trace_ptr = + trace_start - cur_trace_ptr; + else + trace_buf->cur_trace_ptr = + cur_trace_ptr - trace_start; + } else + trace_buf->fill_len = 0; + + + break; + } + + /* + * XXX KDM + * For debugging, five ioctls are needed: + * ALT_ATTACH + * ALT_READ_TG_REG + * ALT_WRITE_TG_REG + * ALT_READ_TG_MEM + * ALT_WRITE_TG_MEM + */ + case ALT_ATTACH: + /* + * From what I can tell, Alteon's Solaris Tigon driver + * only has one character device, so you have to attach + * to the Tigon board you're interested in. This seems + * like a not-so-good way to do things, since unless you + * subsequently specify the unit number of the device + * you're interested in in every ioctl, you'll only be + * able to debug one board at a time. + */ + error = 0; + break; + case ALT_READ_TG_MEM: + case ALT_WRITE_TG_MEM: + { + struct tg_mem *mem_param; + u_int32_t sram_end, scratch_end; + + mem_param = (struct tg_mem *)addr; + + if (sc->ti_hwrev == TI_HWREV_TIGON) { + sram_end = TI_END_SRAM_I; + scratch_end = TI_END_SCRATCH_I; + } else { + sram_end = TI_END_SRAM_II; + scratch_end = TI_END_SCRATCH_II; + } + + /* + * For now, we'll only handle accessing regular SRAM, + * nothing else. + */ + if ((mem_param->tgAddr >= TI_BEG_SRAM) + && ((mem_param->tgAddr + mem_param->len) <= sram_end)) { + /* + * In this instance, we always copy to/from user + * space, so the user space argument is set to 1. + */ + error = ti_copy_mem(sc, mem_param->tgAddr, + mem_param->len, + mem_param->userAddr, 1, + (cmd == ALT_READ_TG_MEM) ? 1 : 0); + } else if ((mem_param->tgAddr >= TI_BEG_SCRATCH) + && (mem_param->tgAddr <= scratch_end)) { + error = ti_copy_scratch(sc, mem_param->tgAddr, + mem_param->len, + mem_param->userAddr, 1, + (cmd == ALT_READ_TG_MEM) ? + 1 : 0, TI_PROCESSOR_A); + } else if ((mem_param->tgAddr >= TI_BEG_SCRATCH_B_DEBUG) + && (mem_param->tgAddr <= TI_BEG_SCRATCH_B_DEBUG)) { + if (sc->ti_hwrev == TI_HWREV_TIGON) { + printf("ti%d: invalid memory range for " + "Tigon I\n", sc->ti_unit); + error = EINVAL; + break; + } + error = ti_copy_scratch(sc, mem_param->tgAddr - + TI_SCRATCH_DEBUG_OFF, + mem_param->len, + mem_param->userAddr, 1, + (cmd == ALT_READ_TG_MEM) ? + 1 : 0, TI_PROCESSOR_B); + } else { + printf("ti%d: memory address %#x len %d is out of " + "supported range\n", sc->ti_unit, + mem_param->tgAddr, mem_param->len); + error = EINVAL; + } + + break; + } + case ALT_READ_TG_REG: + case ALT_WRITE_TG_REG: + { + struct tg_reg *regs; + u_int32_t tmpval; + + regs = (struct tg_reg *)addr; + + /* + * Make sure the address in question isn't out of range. + */ + if (regs->addr > TI_REG_MAX) { + error = EINVAL; + break; + } + if (cmd == ALT_READ_TG_REG) { + bus_space_read_region_4(sc->ti_btag, sc->ti_bhandle, + regs->addr, &tmpval, 1); + regs->data = ntohl(tmpval); +#if 0 + if ((regs->addr == TI_CPU_STATE) + || (regs->addr == TI_CPU_CTL_B)) { + printf("ti%d: register %#x = %#x\n", + sc->ti_unit, regs->addr, tmpval); + } +#endif + } else { + tmpval = htonl(regs->data); + bus_space_write_region_4(sc->ti_btag, sc->ti_bhandle, + regs->addr, &tmpval, 1); + } + + break; + } + default: + error = ENOTTY; + break; + } + return(error); +} + + static void ti_watchdog(ifp) struct ifnet *ifp; { + int s; struct ti_softc *sc; sc = ifp->if_softc; + /* + * When we're debugging, the chip is often stopped for long periods + * of time, and that would normally cause the watchdog timer to fire. + * Since that impedes debugging, we don't want to do that. + */ + s = splimp(); + if (sc->ti_flags & TI_FLAG_DEBUGING) { + splx(s); + return; + } + splx(s); + printf("ti%d: watchdog timeout -- resetting\n", sc->ti_unit); ti_stop(sc); ti_init(sc); Index: pci/if_tireg.h =================================================================== RCS file: /home/ncvs/src/sys/pci/if_tireg.h,v retrieving revision 1.13.2.3 diff -u -r1.13.2.3 if_tireg.h --- pci/if_tireg.h 2000/08/24 00:07:59 1.13.2.3 +++ pci/if_tireg.h 2001/05/14 16:37:32 @@ -343,6 +343,7 @@ #define TI_OPMODE_NO_TX_INTRS 0x00002000 #define TI_OPMODE_NO_RX_INTRS 0x00004000 #define TI_OPMODE_FATAL_ENB 0x40000000 /* not yet implimented */ +#define TI_OPMODE_JUMBO_HDRSPLIT 0x00008000 /* * DMA configuration thresholds. @@ -418,9 +419,56 @@ #define TI_MEM_MAX 0x7FFFFF /* - * Even on the alpha, pci addresses are 32-bit quantities + * Maximum register address on the Tigon. */ +#define TI_REG_MAX 0x3fff +/* + * These values were taken from Alteon's tg.h. + */ +#define TI_BEG_SRAM 0x0 /* host thinks it's here */ +#define TI_BEG_SCRATCH 0xc00000 /* beg of scratch pad area */ +#define TI_END_SRAM_II 0x800000 /* end of SRAM, for 2 MB stuffed */ +#define TI_END_SCRATCH_II 0xc04000 /* end of scratch pad CPU A (16KB) */ +#define TI_END_SCRATCH_B 0xc02000 /* end of scratch pad CPU B (8KB) */ +#define TI_BEG_SCRATCH_B_DEBUG 0xd00000 /* beg of scratch pad for ioctl */ +#define TI_END_SCRATCH_B_DEBUG 0xd02000 /* end of scratch pad for ioctl */ +#define TI_SCRATCH_DEBUG_OFF 0x100000 /* offset for ioctl usage */ +#define TI_END_SRAM_I 0x200000 /* end of SRAM, for 2 MB stuffed */ +#define TI_END_SCRATCH_I 0xc00800 /* end of scratch pad area (2KB) */ +#define TI_BEG_PROM 0x40000000 /* beg of PROM, special access */ +#define TI_BEG_FLASH 0x80000000 /* beg of EEPROM, special access */ +#define TI_END_FLASH 0x80100000 /* end of EEPROM for 1 MB stuff */ +#define TI_BEG_SER_EEPROM 0xa0000000 /* beg of Serial EEPROM (fake out) */ +#define TI_END_SER_EEPROM 0xa0002000 /* end of Serial EEPROM (fake out) */ +#define TI_BEG_REGS 0xc0000000 /* beg of register area */ +#define TI_END_REGS 0xc0000400 /* end of register area */ +#define TI_END_WRITE_REGS 0xc0000180 /* can't write GPRs currently */ +#define TI_BEG_REGS2 0xc0000200 /* beg of second writeable reg area */ +/* the EEPROM is byte addressable in a pretty odd way */ +#define EEPROM_BYTE_LOC 0xff000000 + +/* + * From Alteon's tg.h. + */ +#define TI_PROCESSOR_A 0 +#define TI_PROCESSOR_B 1 +#define TI_CPU_A TG_PROCESSOR_A +#define TI_CPU_B TG_PROCESSOR_B + +/* + * Following macro can be used to access to any of the CPU registers + * It will adjust the address appropriately. + * Parameters: + * reg - The register to access, e.g TI_CPU_CONTROL + * cpu - cpu, i.e PROCESSOR_A or PROCESSOR_B (or TI_CPU_A or TI_CPU_B) + */ +#define CPU_REG(reg, cpu) ((reg) + (cpu) * 0x100) + +/* + Even on the alpha, pci addresses are 32-bit quantities + */ + #ifdef __64_bit_pci_addressing__ typedef struct { u_int64_t ti_addr; @@ -482,192 +530,6 @@ }; /* - * Tigon statistics counters. - */ -struct ti_stats { - /* - * MAC stats, taken from RFC 1643, ethernet-like MIB - */ - volatile u_int32_t dot3StatsAlignmentErrors; /* 0 */ - volatile u_int32_t dot3StatsFCSErrors; /* 1 */ - volatile u_int32_t dot3StatsSingleCollisionFrames; /* 2 */ - volatile u_int32_t dot3StatsMultipleCollisionFrames; /* 3 */ - volatile u_int32_t dot3StatsSQETestErrors; /* 4 */ - volatile u_int32_t dot3StatsDeferredTransmissions; /* 5 */ - volatile u_int32_t dot3StatsLateCollisions; /* 6 */ - volatile u_int32_t dot3StatsExcessiveCollisions; /* 7 */ - volatile u_int32_t dot3StatsInternalMacTransmitErrors; /* 8 */ - volatile u_int32_t dot3StatsCarrierSenseErrors; /* 9 */ - volatile u_int32_t dot3StatsFrameTooLongs; /* 10 */ - volatile u_int32_t dot3StatsInternalMacReceiveErrors; /* 11 */ - /* - * interface stats, taken from RFC 1213, MIB-II, interfaces group - */ - volatile u_int32_t ifIndex; /* 12 */ - volatile u_int32_t ifType; /* 13 */ - volatile u_int32_t ifMtu; /* 14 */ - volatile u_int32_t ifSpeed; /* 15 */ - volatile u_int32_t ifAdminStatus; /* 16 */ -#define IF_ADMIN_STATUS_UP 1 -#define IF_ADMIN_STATUS_DOWN 2 -#define IF_ADMIN_STATUS_TESTING 3 - volatile u_int32_t ifOperStatus; /* 17 */ -#define IF_OPER_STATUS_UP 1 -#define IF_OPER_STATUS_DOWN 2 -#define IF_OPER_STATUS_TESTING 3 -#define IF_OPER_STATUS_UNKNOWN 4 -#define IF_OPER_STATUS_DORMANT 5 - volatile u_int32_t ifLastChange; /* 18 */ - volatile u_int32_t ifInDiscards; /* 19 */ - volatile u_int32_t ifInErrors; /* 20 */ - volatile u_int32_t ifInUnknownProtos; /* 21 */ - volatile u_int32_t ifOutDiscards; /* 22 */ - volatile u_int32_t ifOutErrors; /* 23 */ - volatile u_int32_t ifOutQLen; /* deprecated */ /* 24 */ - volatile u_int8_t ifPhysAddress[8]; /* 8 bytes */ /* 25 - 26 */ - volatile u_int8_t ifDescr[32]; /* 27 - 34 */ - u_int32_t alignIt; /* align to 64 bit for u_int64_ts following */ - /* - * more interface stats, taken from RFC 1573, MIB-IIupdate, - * interfaces group - */ - volatile u_int64_t ifHCInOctets; /* 36 - 37 */ - volatile u_int64_t ifHCInUcastPkts; /* 38 - 39 */ - volatile u_int64_t ifHCInMulticastPkts; /* 40 - 41 */ - volatile u_int64_t ifHCInBroadcastPkts; /* 42 - 43 */ - volatile u_int64_t ifHCOutOctets; /* 44 - 45 */ - volatile u_int64_t ifHCOutUcastPkts; /* 46 - 47 */ - volatile u_int64_t ifHCOutMulticastPkts; /* 48 - 49 */ - volatile u_int64_t ifHCOutBroadcastPkts; /* 50 - 51 */ - volatile u_int32_t ifLinkUpDownTrapEnable; /* 52 */ - volatile u_int32_t ifHighSpeed; /* 53 */ - volatile u_int32_t ifPromiscuousMode; /* 54 */ - volatile u_int32_t ifConnectorPresent; /* follow link state 55 */ - /* - * Host Commands - */ - volatile u_int32_t nicCmdsHostState; /* 56 */ - volatile u_int32_t nicCmdsFDRFiltering; /* 57 */ - volatile u_int32_t nicCmdsSetRecvProdIndex; /* 58 */ - volatile u_int32_t nicCmdsUpdateGencommStats; /* 59 */ - volatile u_int32_t nicCmdsResetJumboRing; /* 60 */ - volatile u_int32_t nicCmdsAddMCastAddr; /* 61 */ - volatile u_int32_t nicCmdsDelMCastAddr; /* 62 */ - volatile u_int32_t nicCmdsSetPromiscMode; /* 63 */ - volatile u_int32_t nicCmdsLinkNegotiate; /* 64 */ - volatile u_int32_t nicCmdsSetMACAddr; /* 65 */ - volatile u_int32_t nicCmdsClearProfile; /* 66 */ - volatile u_int32_t nicCmdsSetMulticastMode; /* 67 */ - volatile u_int32_t nicCmdsClearStats; /* 68 */ - volatile u_int32_t nicCmdsSetRecvJumboProdIndex; /* 69 */ - volatile u_int32_t nicCmdsSetRecvMiniProdIndex; /* 70 */ - volatile u_int32_t nicCmdsRefreshStats; /* 71 */ - volatile u_int32_t nicCmdsUnknown; /* 72 */ - /* - * NIC Events - */ - volatile u_int32_t nicEventsNICFirmwareOperational; /* 73 */ - volatile u_int32_t nicEventsStatsUpdated; /* 74 */ - volatile u_int32_t nicEventsLinkStateChanged; /* 75 */ - volatile u_int32_t nicEventsError; /* 76 */ - volatile u_int32_t nicEventsMCastListUpdated; /* 77 */ - volatile u_int32_t nicEventsResetJumboRing; /* 78 */ - /* - * Ring manipulation - */ - volatile u_int32_t nicRingSetSendProdIndex; /* 79 */ - volatile u_int32_t nicRingSetSendConsIndex; /* 80 */ - volatile u_int32_t nicRingSetRecvReturnProdIndex; /* 81 */ - /* - * Interrupts - */ - volatile u_int32_t nicInterrupts; /* 82 */ - volatile u_int32_t nicAvoidedInterrupts; /* 83 */ - /* - * BD Coalessing Thresholds - */ - volatile u_int32_t nicEventThresholdHit; /* 84 */ - volatile u_int32_t nicSendThresholdHit; /* 85 */ - volatile u_int32_t nicRecvThresholdHit; /* 86 */ - /* - * DMA Attentions - */ - volatile u_int32_t nicDmaRdOverrun; /* 87 */ - volatile u_int32_t nicDmaRdUnderrun; /* 88 */ - volatile u_int32_t nicDmaWrOverrun; /* 89 */ - volatile u_int32_t nicDmaWrUnderrun; /* 90 */ - volatile u_int32_t nicDmaWrMasterAborts; /* 91 */ - volatile u_int32_t nicDmaRdMasterAborts; /* 92 */ - /* - * NIC Resources - */ - volatile u_int32_t nicDmaWriteRingFull; /* 93 */ - volatile u_int32_t nicDmaReadRingFull; /* 94 */ - volatile u_int32_t nicEventRingFull; /* 95 */ - volatile u_int32_t nicEventProducerRingFull; /* 96 */ - volatile u_int32_t nicTxMacDescrRingFull; /* 97 */ - volatile u_int32_t nicOutOfTxBufSpaceFrameRetry; /* 98 */ - volatile u_int32_t nicNoMoreWrDMADescriptors; /* 99 */ - volatile u_int32_t nicNoMoreRxBDs; /* 100 */ - volatile u_int32_t nicNoSpaceInReturnRing; /* 101 */ - volatile u_int32_t nicSendBDs; /* current count 102 */ - volatile u_int32_t nicRecvBDs; /* current count 103 */ - volatile u_int32_t nicJumboRecvBDs; /* current count 104 */ - volatile u_int32_t nicMiniRecvBDs; /* current count 105 */ - volatile u_int32_t nicTotalRecvBDs; /* current count 106 */ - volatile u_int32_t nicTotalSendBDs; /* current count 107 */ - volatile u_int32_t nicJumboSpillOver; /* 108 */ - volatile u_int32_t nicSbusHangCleared; /* 109 */ - volatile u_int32_t nicEnqEventDelayed; /* 110 */ - /* - * Stats from MAC rx completion - */ - volatile u_int32_t nicMacRxLateColls; /* 111 */ - volatile u_int32_t nicMacRxLinkLostDuringPkt; /* 112 */ - volatile u_int32_t nicMacRxPhyDecodeErr; /* 113 */ - volatile u_int32_t nicMacRxMacAbort; /* 114 */ - volatile u_int32_t nicMacRxTruncNoResources; /* 115 */ - /* - * Stats from the mac_stats area - */ - volatile u_int32_t nicMacRxDropUla; /* 116 */ - volatile u_int32_t nicMacRxDropMcast; /* 117 */ - volatile u_int32_t nicMacRxFlowControl; /* 118 */ - volatile u_int32_t nicMacRxDropSpace; /* 119 */ - volatile u_int32_t nicMacRxColls; /* 120 */ - /* - * MAC RX Attentions - */ - volatile u_int32_t nicMacRxTotalAttns; /* 121 */ - volatile u_int32_t nicMacRxLinkAttns; /* 122 */ - volatile u_int32_t nicMacRxSyncAttns; /* 123 */ - volatile u_int32_t nicMacRxConfigAttns; /* 124 */ - volatile u_int32_t nicMacReset; /* 125 */ - volatile u_int32_t nicMacRxBufDescrAttns; /* 126 */ - volatile u_int32_t nicMacRxBufAttns; /* 127 */ - volatile u_int32_t nicMacRxZeroFrameCleanup; /* 128 */ - volatile u_int32_t nicMacRxOneFrameCleanup; /* 129 */ - volatile u_int32_t nicMacRxMultipleFrameCleanup; /* 130 */ - volatile u_int32_t nicMacRxTimerCleanup; /* 131 */ - volatile u_int32_t nicMacRxDmaCleanup; /* 132 */ - /* - * Stats from the mac_stats area - */ - volatile u_int32_t nicMacTxCollisionHistogram[15]; /* 133 */ - /* - * MAC TX Attentions - */ - volatile u_int32_t nicMacTxTotalAttns; /* 134 */ - /* - * NIC Profile - */ - volatile u_int32_t nicProfile[32]; /* 135 */ - /* - * Pat to 1024 bytes. - */ - u_int32_t pad[75]; -}; -/* * Tigon general information block. This resides in host memory * and contains the status counters, ring control blocks and * producer pointers. @@ -1035,7 +897,7 @@ #define TI_SSLOTS 256 #define TI_MSLOTS 256 -#define TI_JSLOTS 384 +#define TI_JSLOTS 256 #define TI_JRAWLEN (TI_JUMBO_FRAMELEN + ETHER_ALIGN + sizeof(u_int64_t)) #define TI_JLEN (TI_JRAWLEN + (sizeof(u_int64_t) - \ @@ -1046,7 +908,7 @@ struct ti_jslot { caddr_t ti_buf; - int ti_inuse; + int ti_inuse; }; /* @@ -1057,7 +919,11 @@ */ struct ti_ring_data { struct ti_rx_desc ti_rx_std_ring[TI_STD_RX_RING_CNT]; +#ifdef PRIVATE_JUMBOS struct ti_rx_desc ti_rx_jumbo_ring[TI_JUMBO_RX_RING_CNT]; +#else + struct ti_rx_desc_ext ti_rx_jumbo_ring[TI_JUMBO_RX_RING_CNT]; +#endif struct ti_rx_desc ti_rx_mini_ring[TI_MINI_RX_RING_CNT]; struct ti_rx_desc ti_rx_return_ring[TI_RETURN_RING_CNT]; struct ti_event_desc ti_event_ring[TI_EVENT_RING_CNT]; @@ -1113,7 +979,16 @@ SLIST_ENTRY(ti_jpool_entry) jpool_entries; }; +typedef enum { + TI_FLAG_NONE = 0x00, + TI_FLAG_DEBUGING = 0x01, + TI_FLAG_WAIT_FOR_LINK = 0x02 +} ti_flag_vals; + +#ifdef _KERNEL + struct ti_softc { + STAILQ_ENTRY(ti_softc) ti_links; struct arpcom arpcom; /* interface info */ bus_space_handle_t ti_bhandle; vm_offset_t ti_vhandle; @@ -1149,7 +1024,11 @@ u_int32_t ti_tx_buf_ratio; int ti_if_flags; int ti_txcnt; + ti_flag_vals ti_flags; + dev_t dev; }; + +#endif /* * Microchip Technology 24Cxx EEPROM control bytes Index: pci/ti_fw2.h =================================================================== RCS file: /home/ncvs/src/sys/pci/ti_fw2.h,v retrieving revision 1.6.2.3 diff -u -r1.6.2.3 ti_fw2.h --- pci/ti_fw2.h 2000/08/24 00:07:57 1.6.2.3 +++ pci/ti_fw2.h 2001/05/14 16:14:40 @@ -1,35 +1,29 @@ /* - * Generated by genfw.c - * Built on Wed Jul 26 10:40:31 2000 by wpaul@brak.osd.bsdi.com + * Generated by Ken's special genfw.c + * Built on Thu Jul 20 17:35:07 EDT 2000 by gallatin@grasshopper.cs.duke.edu * OS: FreeBSD 4.0-RELEASE - * - * Note: this is really firmware release 12.4.11 with some minor - * modifications. Release 12.4.13 apparently fails to handle 10/100 - * modes in some cases. - * - * $FreeBSD: src/sys/pci/ti_fw2.h,v 1.6.2.3 2000/08/24 00:07:57 wpaul Exp $ */ static int tigon2FwReleaseMajor = 0xc; static int tigon2FwReleaseMinor = 0x4; static int tigon2FwReleaseFix = 0xd; static u_int32_t tigon2FwStartAddr = 0x00004000; static u_int32_t tigon2FwTextAddr = 0x00004000; -static int tigon2FwTextLen = 0x11c80; -static u_int32_t tigon2FwRodataAddr = 0x00015c80; -static int tigon2FwRodataLen = 0x10d0; -static u_int32_t tigon2FwDataAddr = 0x00016d80; -static int tigon2FwDataLen = 0x1c0; -static u_int32_t tigon2FwSbssAddr = 0x00016f40; -static int tigon2FwSbssLen = 0xcc; -static u_int32_t tigon2FwBssAddr = 0x00017010; -static int tigon2FwBssLen = 0x20c0; +int tigon2FwTextLen = 0x13130; +static u_int32_t tigon2FwRodataAddr = 0x00017130; +int tigon2FwRodataLen = 0x1106; +static u_int32_t tigon2FwDataAddr = 0x00018420; +int tigon2FwDataLen = 0x180; +static u_int32_t tigon2FwSbssAddr = 0x000185a0; +int tigon2FwSbssLen = 0xcc; +static u_int32_t tigon2FwBssAddr = 0x00018670; +int tigon2FwBssLen = 0x20c0; static u_int32_t tigon2FwText[] = { 0x0, 0x10000003, 0x0, 0xd, 0xd, -0x3c1d0001, 0x8fbd6de0, 0x3a0f021, 0x3c100000, -0x26104000, 0xc0010c0, 0x0, 0xd, -0x3c1d0001, 0x8fbd6de4, 0x3a0f021, 0x3c100000, -0x26104000, 0xc0017e0, 0x0, 0xd, +0x3c1d0002, 0x8fbd8460, 0x3a0f021, 0x3c100000, +0x26104000, 0xc001082, 0x0, 0xd, +0x3c1d0002, 0x8fbd8464, 0x3a0f021, 0x3c100000, +0x26104000, 0xc0018cc, 0x0, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, @@ -41,470 +35,529 @@ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2000008, -0x0, 0x800172f, 0x3c0a0001, 0x800172f, -0x3c0a0002, 0x800172f, 0x0, 0x8002ca7, -0x0, 0x8002c4a, 0x0, 0x800172f, -0x3c0a0004, 0x8003286, 0x0, 0x8001a52, -0x0, 0x8003948, 0x0, 0x80038ef, -0x0, 0x800172f, 0x3c0a0006, 0x80039b6, -0x3c0a0007, 0x800172f, 0x3c0a0008, 0x800172f, -0x3c0a0009, 0x8003a0e, 0x0, 0x8002ea1, -0x0, 0x800172f, 0x3c0a000b, 0x800172f, -0x3c0a000c, 0x800172f, 0x3c0a000d, 0x80028f7, -0x0, 0x800288c, 0x0, 0x800172f, -0x3c0a000e, 0x800208c, 0x0, 0x8001964, -0x0, 0x8001a04, 0x0, 0x8003ca2, -0x0, 0x8003c90, 0x0, 0x800172f, -0x0, 0x800191a, 0x0, 0x800172f, -0x0, 0x800172f, 0x3c0a0013, 0x800172f, -0x3c0a0014, 0x0, 0x0, 0x0, -0x0, 0x0, 0x0, 0x0, -0x0, 0x0, 0x0, 0x0, -0x0, 0x0, 0x0, 0x0, -0x0, 0x0, 0x0, 0x0, -0x0, 0x0, 0x0, 0x0, -0x0, 0x0, 0x0, 0x0, -0x0, 0x0, 0x0, 0x0, -0x0, 0x0, 0x0, 0x0, -0x0, 0x0, 0x0, 0x0, -0x0, 0x0, 0x0, 0x0, -0x0, 0x0, 0x0, 0x0, -0x0, 0x0, 0x0, 0x0, -0x0, 0x0, 0x0, 0x0, -0x0, 0x0, 0x0, 0x0, -0x0, 0x0, 0x0, 0x27bdffe0, -0x3c1cc000, 0xafbf001c, 0xafb00018, 0x8f820140, -0x24030003, 0xaf8300ec, 0x34420004, 0xc002b1c, -0xaf820140, 0x3c0100c0, 0xc001763, 0xac203ffc, -0x401821, 0x3c020010, 0x3c010001, 0xac236f5c, -0x10620011, 0x43102b, 0x14400002, 0x3c020020, -0x3c020008, 0x1062000c, 0x24050100, 0x3c060001, -0x8cc66f5c, 0x3c040001, 0x24845d34, 0x3821, -0xafa00010, 0xc002b37, 0xafa00014, 0x3c020020, -0x3c010001, 0xac226f5c, 0x24020008, 0x3c010001, -0xac226f74, 0x2402001f, 0x3c010001, 0xac226f84, -0x24020016, 0x3c010001, 0xac226f58, 0x3c05fffe, -0x34a56f08, 0x3c020001, 0x8c426f5c, 0x3c030002, -0x246390d0, 0x3c040001, 0x8c846d84, 0x431023, +0x0, 0x80017d9, 0x3c0a0001, 0x80017d9, +0x3c0a0002, 0x80017d9, 0x0, 0x8002ec4, +0x0, 0x8002e4e, 0x0, 0x80017d9, +0x3c0a0004, 0x80035a3, 0x0, 0x8001b5a, +0x0, 0x8003e2d, 0x0, 0x8003dbb, +0x0, 0x80017d9, 0x3c0a0006, 0x8003eb4, +0x3c0a0007, 0x80017d9, 0x3c0a0008, 0x80017d9, +0x3c0a0009, 0x8003f25, 0x0, 0x80030d9, +0x0, 0x80017d9, 0x3c0a000b, 0x80017d9, +0x3c0a000c, 0x80017d9, 0x3c0a000d, 0x8002af6, +0x0, 0x8002a8a, 0x0, 0x80017d9, +0x3c0a000e, 0x800219b, 0x0, 0x8001a69, +0x0, 0x8001b0b, 0x0, 0x8004203, +0x0, 0x80041f1, 0x0, 0x80017d9, +0x0, 0x8001a1f, 0x0, 0x80017d9, +0x0, 0x80017d9, 0x3c0a0013, 0x80017d9, +0x3c0a0014, 0x27bdffe0, 0x3c1cc000, 0xafbf001c, +0xafb00018, 0x8f820140, 0x24030003, 0xaf8300ec, +0x34420004, 0xaf820140, 0xc002d20, 0x0, +0x3c0100c0, 0xac203ffc, 0xc00184f, 0x0, +0x401821, 0x3c020010, 0x3c010002, 0xac2385bc, +0x10620025, 0x43102b, 0x14400002, 0x3c020020, +0x3c020008, 0x10620020, 0x24050100, 0x3c040001, +0x248471e4, 0x3c060002, 0x8cc685bc, 0x3821, +0xafa00010, 0xc002d3b, 0xafa00014, 0x3c040001, +0x248471f0, 0x24020256, 0xafa20010, 0xafa00014, +0x8f860144, 0x3c070001, 0x24e771f8, 0xc002d3b, +0x3405dead, 0x8f82011c, 0x34420002, 0xaf82011c, +0x8f820220, 0x34420004, 0xaf820220, 0x8f830140, +0x3c020020, 0x3c010002, 0xac2285bc, 0x3c020001, +0x621825, 0xaf830140, 0x24020008, 0x3c010002, +0xac2285d4, 0x2402001f, 0x3c010002, 0xac2285e4, +0x24020016, 0x3c010002, 0xac2285b8, 0x3c05fffe, +0x34a56f08, 0x3c020002, 0x8c4285bc, 0x3c030002, +0x2463a730, 0x3c040002, 0x8c848424, 0x431023, 0x14800002, 0x458021, 0x2610fa38, 0x2402f000, -0x2028024, 0xc001785, 0x2002021, 0x2022823, +0x2028024, 0xc001871, 0x2002021, 0x2022823, 0x3c040020, 0x821823, 0x651823, 0x247bb000, 0x3c03fffe, 0x3463bf08, 0x363b821, 0x3c0600bf, -0x34c6f000, 0x3c070001, 0x8ce76d80, 0x3c0300bf, -0x3463e000, 0x852023, 0x3c010001, 0xac246f68, -0x822023, 0x3c010001, 0xac256f50, 0x52842, -0x3c010001, 0xac226f44, 0x27620ffc, 0x3c010001, -0xac226de0, 0x27621ffc, 0xdb3023, 0x7b1823, -0x3c010001, 0xac246f48, 0x3c010001, 0xac256f6c, -0x3c010001, 0xac226de4, 0xaf860150, 0x10e00011, -0xaf830250, 0x3c1d0001, 0x8fbd6d8c, 0x3a0f021, -0xc001749, 0x0, 0x3c020001, 0x8c426d90, -0x3c030001, 0x8c636d94, 0x2442fe00, 0x24630200, -0x3c010001, 0xac226d90, 0x3c010001, 0x10000004, -0xac236d94, 0x3c1d0001, 0x8fbd6de0, 0x3a0f021, -0x3c020001, 0x8c426d84, 0x1040000d, 0x26fafa38, -0x3c020001, 0x8c426d90, 0x3c030001, 0x8c636d94, -0x3c1a0001, 0x8f5a6d94, 0x2442fa38, 0x246305c8, -0x3c010001, 0xac226d90, 0x3c010001, 0xac236d94, -0x3c020001, 0x8c426d88, 0x14400003, 0x0, -0x3c010001, 0xac206d90, 0xc001151, 0x0, -0x8fbf001c, 0x8fb00018, 0x3e00008, 0x27bd0020, -0x3c020001, 0x8c426d90, 0x3c030001, 0x8c636d94, -0x27bdff98, 0xafb00048, 0x3c100001, 0x8e106778, -0xafb20050, 0x3c120000, 0x26524100, 0xafbf0060, -0xafbe005c, 0xafb50058, 0xafb30054, 0xafb1004c, -0xafa20034, 0xafa30030, 0xafa00010, 0xafa00014, -0x8f860040, 0x3c040001, 0x24845d40, 0x24050200, -0x3c010001, 0xac326f40, 0xc002b37, 0x2003821, -0x8f830040, 0x3c02f000, 0x621824, 0x3c026000, -0x1062000b, 0xa3a0003f, 0x240e0001, 0x3c040001, -0x24845d48, 0xa3ae003f, 0xafa00010, 0xafa00014, -0x8f860040, 0x24050300, 0xc002b37, 0x2003821, -0x8f820240, 0x3c030001, 0x431025, 0xaf820240, -0xaf800048, 0x8f820048, 0x14400005, 0x0, -0xaf800048, 0x8f820048, 0x10400004, 0x0, -0xaf800048, 0x10000003, 0x2e02021, 0xaf80004c, -0x2e02021, 0x3c050001, 0xc002ba4, 0x34a540f8, -0x3402021, 0xc002ba4, 0x240505c8, 0x3c020001, -0x8c426f68, 0x3c0d0001, 0x8dad6f48, 0x3c030001, -0x8c636f44, 0x3c080001, 0x8d086f50, 0x3c090001, -0x8d296f6c, 0x3c0a0001, 0x8d4a6f74, 0x3c0b0001, -0x8d6b6f84, 0x3c0c0001, 0x8d8c6f58, 0x3c040001, -0x24845d54, 0x24050400, 0xaf42013c, 0x8f42013c, -0x24060001, 0x24070001, 0xaf400000, 0xaf4d0138, -0xaf430144, 0xaf480148, 0xaf49014c, 0xaf4a0150, -0xaf4b0154, 0xaf4c0158, 0x2442ff80, 0xaf420140, -0x24020001, 0xafa20010, 0xc002b37, 0xafa00014, -0x8f420138, 0xafa20010, 0x8f42013c, 0xafa20014, -0x8f460144, 0x8f470148, 0x3c040001, 0x24845d60, -0xc002b37, 0x24050500, 0xafb70010, 0xafba0014, -0x8f46014c, 0x8f470150, 0x3c040001, 0x24845d6c, -0xc002b37, 0x24050600, 0x3c020001, 0x8c426f5c, -0x3603821, 0x3c060002, 0x24c690d0, 0x2448ffff, -0x1061824, 0xe81024, 0x43102b, 0x10400006, -0x24050900, 0x3c040001, 0x24845d78, 0xafa80010, -0xc002b37, 0xafa00014, 0x8f82000c, 0xafa20010, -0x8f82003c, 0xafa20014, 0x8f860000, 0x8f870004, -0x3c040001, 0x24845d84, 0xc002b37, 0x24051000, -0x8c020220, 0x8c030224, 0x8c060218, 0x8c07021c, -0x3c040001, 0x24845d8c, 0x24051100, 0xafa20010, -0xc002b37, 0xafa30014, 0xaf800054, 0xaf80011c, -0x8c020218, 0x30420002, 0x10400009, 0x0, -0x8c020220, 0x3c030002, 0x34630004, 0x431025, -0xaf42000c, 0x8c02021c, 0x10000008, 0x34420004, -0x8c020220, 0x3c030002, 0x34630006, 0x431025, -0xaf42000c, 0x8c02021c, 0x34420006, 0xaf420014, -0x8c020218, 0x30420010, 0x1040000a, 0x0, -0x8c02021c, 0x34420004, 0xaf420010, 0x8c020220, -0x3c03000a, 0x34630004, 0x431025, 0x10000009, -0xaf420008, 0x8c020220, 0x3c03000a, 0x34630006, -0x431025, 0xaf420008, 0x8c02021c, 0x34420006, -0xaf420010, 0x24020001, 0xaf8200a0, 0xaf8200b0, -0x8f830054, 0x8f820054, 0xaf8000d0, 0xaf8000c0, -0x10000002, 0x24630064, 0x8f820054, 0x621023, -0x2c420065, 0x1440fffc, 0x0, 0x8c040208, -0x8c05020c, 0x26e20028, 0xaee20020, 0x24020490, -0xaee20010, 0xaee40008, 0xaee5000c, 0x26e40008, -0x8c820000, 0x8c830004, 0xaf820090, 0xaf830094, -0x8c820018, 0xaf8200b4, 0x9482000a, 0xaf82009c, -0x8f420014, 0xaf8200b0, 0x8f8200b0, 0x30420004, -0x1440fffd, 0x0, 0x8f8200b0, 0x3c03ef00, -0x431024, 0x10400021, 0x0, 0x8f8200b4, -0xafa20010, 0x8f820090, 0x8f830094, 0x3c040001, -0x24845d94, 0xafa30014, 0x8f8600b0, 0x8f87009c, -0x3c050001, 0xc002b37, 0x34a5200d, 0x3c040001, -0x24845da0, 0x240203c3, 0xafa20010, 0xafa00014, -0x8f860144, 0x3c070001, 0x24e75da8, 0xc002b37, +0x34c6f000, 0x3c070002, 0x8ce78420, 0x3c0300bf, +0x3463e000, 0x852023, 0x3c010002, 0xac2485c8, +0x822023, 0x3c010002, 0xac2585b0, 0x52842, +0x3c010002, 0xac2285a4, 0x27620ffc, 0x3c010002, +0xac228460, 0x27621ffc, 0xdb3023, 0x7b1823, +0x3c010002, 0xac2485a8, 0x3c010002, 0xac2585cc, +0x3c010002, 0xac228464, 0xaf860150, 0xaf830250, +0x10e00027, 0x33620fff, 0x10400014, 0x2402028b, +0x3c040001, 0x248471f0, 0xafa20010, 0xafa00014, +0x8f860144, 0x3c070001, 0x24e771f8, 0xc002d3b, 0x3405dead, 0x8f82011c, 0x34420002, 0xaf82011c, 0x8f820220, 0x34420004, 0xaf820220, 0x8f820140, -0x3c030001, 0x431025, 0xaf820140, 0x96e20472, -0x96e60452, 0x96e70462, 0xafa20010, 0x96e20482, -0x3c040001, 0x24845db4, 0x24051200, 0xc002b37, -0xafa20014, 0x96f00452, 0x32020001, 0x10400002, -0xb021, 0x24160001, 0x32020002, 0x54400001, -0x36d60002, 0x32020008, 0x54400001, 0x36d60004, -0x32020010, 0x54400001, 0x36d60008, 0x32020020, -0x54400001, 0x36d60010, 0x32020040, 0x54400001, -0x36d60020, 0x32020080, 0x54400001, 0x36d60040, -0x96e60482, 0x30c20200, 0x54400001, 0x36d64000, -0x96e30472, 0x30620200, 0x10400003, 0x30620100, -0x10000003, 0x36d62000, 0x54400001, 0x36d61000, -0x96f00462, 0x32c24000, 0x14400004, 0x3207009b, -0x30c2009b, 0x14e20007, 0x240e0001, 0x32c22000, -0x1440000d, 0x32020001, 0x3062009b, 0x10e20009, -0x240e0001, 0x3c040001, 0x24845dc0, 0x24051300, -0x2003821, 0xa3ae003f, 0xafa30010, 0xc002b37, -0xafa00014, 0x32020001, 0x54400001, 0x36d60080, +0x3c030001, 0x431025, 0xaf820140, 0x3c1d0002, +0x8fbd842c, 0x3a0f021, 0xc001807, 0x0, +0x3c020002, 0x8c428430, 0x3c030002, 0x8c638434, +0x2442fe00, 0x24630200, 0x3c010002, 0xac228430, +0x3c010002, 0xac238434, 0x10000004, 0x0, +0x3c1d0002, 0x8fbd8460, 0x3a0f021, 0x3c020002, +0x8c428424, 0x1040000d, 0x26fafa38, 0x3c020002, +0x8c428430, 0x3c030002, 0x8c638434, 0x3c1a0002, +0x8f5a8434, 0x2442fa38, 0x246305c8, 0x3c010002, +0xac228430, 0x3c010002, 0xac238434, 0x3c020002, +0x8c428428, 0x14400003, 0x0, 0x3c010002, +0xac208430, 0xc001140, 0x0, 0x8fbf001c, +0x8fb00018, 0x3e00008, 0x27bd0020, 0x3c020002, +0x8c428430, 0x3c030002, 0x8c638434, 0x27bdff98, +0xafb00048, 0x3c100001, 0x8e107b94, 0xafb20050, +0x3c120000, 0x26524100, 0xafbf0060, 0xafbe005c, +0xafb50058, 0xafb30054, 0xafb1004c, 0xafa20034, +0xafa30030, 0xafa00010, 0xafa00014, 0x8f860040, +0x3c040001, 0x24847204, 0x24050200, 0x3c010002, +0xac3285a0, 0xc002d3b, 0x2003821, 0x8f830040, +0x3c02f000, 0x621824, 0x3c026000, 0x1062001f, +0xa3a0003f, 0x3c040001, 0x2484720c, 0xafa00010, +0xafa00014, 0x8f860040, 0x24050300, 0xc002d3b, +0x2003821, 0x3c040001, 0x248471f0, 0x240202e1, +0xafa20010, 0xafa00014, 0x8f860144, 0x3c070001, +0x24e771f8, 0xc002d3b, 0x3405dead, 0x8f82011c, +0x34420002, 0xaf82011c, 0x8f820220, 0x34420004, +0xaf820220, 0x8f820140, 0x240e0001, 0x3c030001, +0xa3ae003f, 0x431025, 0xaf820140, 0x8f820240, +0x3c030001, 0x431025, 0xaf820240, 0xaf800048, +0x8f820048, 0x14400005, 0x0, 0xaf800048, +0x8f820048, 0x10400004, 0x0, 0xaf800048, +0x10000003, 0x2e02021, 0xaf80004c, 0x2e02021, +0x3c050001, 0xc002da8, 0x34a540f8, 0x3402021, +0xc002da8, 0x240505c8, 0x3c020002, 0x8c4285c8, +0x3c0d0002, 0x8dad85a8, 0x3c030002, 0x8c6385a4, +0x3c080002, 0x8d0885b0, 0x3c090002, 0x8d2985cc, +0x3c0a0002, 0x8d4a85d4, 0x3c0b0002, 0x8d6b85e4, +0x3c0c0002, 0x8d8c85b8, 0x3c040001, 0x24847218, +0x24050400, 0xaf42013c, 0x8f42013c, 0x24060001, +0x24070001, 0xaf400000, 0xaf4d0138, 0xaf430144, +0xaf480148, 0xaf49014c, 0xaf4a0150, 0xaf4b0154, +0xaf4c0158, 0x2442ff80, 0xaf420140, 0x24020001, +0xafa20010, 0xc002d3b, 0xafa00014, 0x8f420138, +0xafa20010, 0x8f42013c, 0xafa20014, 0x8f460144, +0x8f470148, 0x3c040001, 0x24847224, 0xc002d3b, +0x24050500, 0xafb70010, 0xafba0014, 0x8f46014c, +0x8f470150, 0x3c040001, 0x24847230, 0xc002d3b, +0x24050600, 0x3c020002, 0x8c4285bc, 0x3603821, +0x3c060002, 0x24c6a730, 0x2448ffff, 0x1061824, +0xe81024, 0x43102b, 0x1040001a, 0x24050900, +0x3c040001, 0x2484723c, 0xafa80010, 0xc002d3b, +0xafa00014, 0x3c040001, 0x248471f0, 0x2402033a, +0xafa20010, 0xafa00014, 0x8f860144, 0x3c070001, +0x24e771f8, 0xc002d3b, 0x3405dead, 0x8f82011c, +0x34420002, 0xaf82011c, 0x8f820220, 0x34420004, +0xaf820220, 0x8f820140, 0x3c030001, 0x431025, +0xaf820140, 0x8f82000c, 0xafa20010, 0x8f82003c, +0xafa20014, 0x8f860000, 0x8f870004, 0x3c040001, +0x24847248, 0xc002d3b, 0x24051000, 0x8c020220, +0x8c030224, 0x8c060218, 0x8c07021c, 0x3c040001, +0x24847250, 0x24051100, 0xafa20010, 0xc002d3b, +0xafa30014, 0xaf800054, 0xaf80011c, 0x8c020218, +0x30420002, 0x10400009, 0x0, 0x8c020220, +0x3c030002, 0x34630004, 0x431025, 0xaf42000c, +0x8c02021c, 0x10000008, 0x34420004, 0x8c020220, +0x3c030002, 0x34630006, 0x431025, 0xaf42000c, +0x8c02021c, 0x34420006, 0xaf420014, 0x8c020218, +0x30420010, 0x1040000a, 0x0, 0x8c02021c, +0x34420004, 0xaf420010, 0x8c020220, 0x3c03000a, +0x34630004, 0x431025, 0x10000009, 0xaf420008, +0x8c020220, 0x3c03000a, 0x34630006, 0x431025, +0xaf420008, 0x8c02021c, 0x34420006, 0xaf420010, +0x24020001, 0xaf8200a0, 0xaf8200b0, 0x8f830054, +0x8f820054, 0xaf8000d0, 0xaf8000c0, 0x10000002, +0x24630064, 0x8f820054, 0x621023, 0x2c420065, +0x1440fffc, 0x0, 0x8c040208, 0x8c05020c, +0x26e20028, 0xaee20020, 0x24020490, 0xaee20010, +0xaee40008, 0xaee5000c, 0x26e40008, 0x8c820000, +0x8c830004, 0xaf820090, 0xaf830094, 0x8c820018, +0xaf8200b4, 0x9482000a, 0xaf82009c, 0x8f420014, +0xaf8200b0, 0x8f8200b0, 0x30420004, 0x1440fffd, +0x0, 0x8f8200b0, 0x3c03ef00, 0x431024, +0x10400021, 0x0, 0x8f8200b4, 0xafa20010, +0x8f820090, 0x8f830094, 0x3c040001, 0x24847258, +0xafa30014, 0x8f8600b0, 0x8f87009c, 0x3c050001, +0xc002d3b, 0x34a5200d, 0x3c040001, 0x248471f0, +0x240203c4, 0xafa20010, 0xafa00014, 0x8f860144, +0x3c070001, 0x24e771f8, 0xc002d3b, 0x3405dead, +0x8f82011c, 0x34420002, 0xaf82011c, 0x8f820220, +0x34420004, 0xaf820220, 0x8f820140, 0x3c030001, +0x431025, 0xaf820140, 0x96e20472, 0x96e60452, +0x96e70462, 0xafa20010, 0x96e20482, 0x3c040001, +0x24847264, 0x24051200, 0xc002d3b, 0xafa20014, +0x96f00452, 0x32020001, 0x10400002, 0xb021, +0x24160001, 0x32020002, 0x54400001, 0x36d60002, +0x32020008, 0x54400001, 0x36d60004, 0x32020010, +0x54400001, 0x36d60008, 0x32020020, 0x54400001, +0x36d60010, 0x32020040, 0x54400001, 0x36d60020, +0x32020080, 0x54400001, 0x36d60040, 0x96e60482, +0x30c20200, 0x54400001, 0x36d64000, 0x96e30472, +0x30620200, 0x10400003, 0x30620100, 0x10000003, +0x36d62000, 0x54400001, 0x36d61000, 0x96f00462, +0x32c24000, 0x14400004, 0x3207009b, 0x30c2009b, +0x14e20007, 0x0, 0x32c22000, 0x14400022, +0x32020001, 0x3062009b, 0x10e2001f, 0x32020001, +0x3c040001, 0x24847270, 0x24051300, 0x2003821, +0xafa30010, 0xc002d3b, 0xafa00014, 0x3c040001, +0x248471f0, 0x24020400, 0xafa20010, 0xafa00014, +0x8f860144, 0x3c070001, 0x24e771f8, 0xc002d3b, +0x3405dead, 0x8f82011c, 0x34420002, 0xaf82011c, +0x8f820220, 0x34420004, 0xaf820220, 0x8f820140, +0x240e0001, 0x3c030001, 0xa3ae003f, 0x431025, +0xaf820140, 0x32020001, 0x54400001, 0x36d60080, 0x32020002, 0x54400001, 0x36d60100, 0x32020008, 0x54400001, 0x36d60200, 0x32020010, 0x54400001, 0x36d60400, 0x32020080, 0x54400001, 0x36d60800, 0x8c020218, 0x30420200, 0x10400002, 0x3c020008, -0x2c2b025, 0x8c020218, 0x30420800, 0x10400002, -0x3c020080, 0x2c2b025, 0x8c020218, 0x30420400, -0x10400002, 0x3c020100, 0x2c2b025, 0x8c020218, -0x30420100, 0x10400002, 0x3c020200, 0x2c2b025, -0x8c020218, 0x30420080, 0x10400002, 0x3c020400, -0x2c2b025, 0x8c020218, 0x30422000, 0x10400002, -0x3c020010, 0x2c2b025, 0x8c020218, 0x30424000, -0x10400002, 0x3c020020, 0x2c2b025, 0x8c020218, -0x30421000, 0x10400002, 0x3c020040, 0x2c2b025, -0x8ee20498, 0x8ee3049c, 0xaf420160, 0xaf430164, -0x8ee204a0, 0x8ee304a4, 0xaf420168, 0xaf43016c, -0x8ee204a8, 0x8ee304ac, 0xaf420170, 0xaf430174, -0x8ee20428, 0x8ee3042c, 0xaf420178, 0xaf43017c, -0x8ee20448, 0x8ee3044c, 0xaf420180, 0xaf430184, -0x8ee20458, 0x8ee3045c, 0xaf420188, 0xaf43018c, -0x8ee20468, 0x8ee3046c, 0xaf420190, 0xaf430194, -0x8ee20478, 0x8ee3047c, 0xaf420198, 0xaf43019c, -0x8ee20488, 0x8ee3048c, 0xaf4201a0, 0xaf4301a4, -0x8ee204b0, 0x8ee304b4, 0x24040080, 0xaf4201a8, -0xaf4301ac, 0xc002ba4, 0x24050080, 0x8c02025c, -0x27440224, 0xaf4201f0, 0x8c020260, 0x24050200, -0x24060008, 0xc002bbb, 0xaf4201f8, 0x3c043b9a, -0x3484ca00, 0x3821, 0x24020006, 0x24030002, -0xaf4201f4, 0x240203e8, 0xaf430204, 0xaf430200, -0xaf4401fc, 0xaf420294, 0x24020001, 0xaf430290, -0xaf42029c, 0x3c030001, 0x671821, 0x90636d98, -0x3471021, 0x24e70001, 0xa043022c, 0x2ce2000f, -0x1440fff8, 0x3471821, 0x24e70001, 0x3c080001, -0x350840f8, 0x8f820040, 0x3c040001, 0x24845dcc, -0x24051400, 0x21702, 0x24420030, 0xa062022c, -0x3471021, 0xa040022c, 0x8c070218, 0x2c03021, -0x240205c8, 0xafa20010, 0xc002b37, 0xafa80014, -0x3c040001, 0x24845dd8, 0x3c050000, 0x24a55c80, -0x24060010, 0x27b10030, 0x2203821, 0x27b30034, -0xc0017a3, 0xafb30010, 0x3c030001, 0x8c636d88, -0x1060000a, 0x408021, 0x8fa30030, 0x2405ff00, -0x8fa20034, 0x246400ff, 0x852024, 0x831823, -0x431023, 0xafa20034, 0xafa40030, 0x3c040001, -0x24845de4, 0x3c050000, 0x24a54100, 0x24060108, -0x2203821, 0xc0017a3, 0xafb30010, 0x409021, -0x32c20003, 0x3c010001, 0xac326f40, 0x10400045, -0x2203821, 0x8f820050, 0x3c030010, 0x431024, -0x10400016, 0x0, 0x8c020218, 0x30420040, -0x1040000f, 0x24020001, 0x8f820050, 0x8c030218, -0x240e0001, 0x3c040001, 0x24845df0, 0xa3ae003f, +0x2c2b025, 0x8c020218, 0x30428000, 0x10400002, +0x3c021000, 0x2c2b025, 0x8c020218, 0x30420800, +0x10400002, 0x3c020080, 0x2c2b025, 0x8c020218, +0x30420400, 0x10400002, 0x3c020100, 0x2c2b025, +0x8c020218, 0x30420100, 0x10400002, 0x3c020200, +0x2c2b025, 0x8c020218, 0x30420080, 0x10400002, +0x3c020400, 0x2c2b025, 0x8c020218, 0x30422000, +0x10400002, 0x3c020010, 0x2c2b025, 0x8c020218, +0x30424000, 0x10400002, 0x3c020020, 0x2c2b025, +0x8c020218, 0x30421000, 0x10400002, 0x3c020040, +0x2c2b025, 0x8ee20498, 0x8ee3049c, 0xaf420160, +0xaf430164, 0x8ee204a0, 0x8ee304a4, 0xaf420168, +0xaf43016c, 0x8ee204a8, 0x8ee304ac, 0xaf420170, +0xaf430174, 0x8ee20428, 0x8ee3042c, 0xaf420178, +0xaf43017c, 0x8ee20448, 0x8ee3044c, 0xaf420180, +0xaf430184, 0x8ee20458, 0x8ee3045c, 0xaf420188, +0xaf43018c, 0x8ee20468, 0x8ee3046c, 0xaf420190, +0xaf430194, 0x8ee20478, 0x8ee3047c, 0xaf420198, +0xaf43019c, 0x8ee20488, 0x8ee3048c, 0xaf4201a0, +0xaf4301a4, 0x8ee204b0, 0x8ee304b4, 0x24040080, +0xaf4201a8, 0xaf4301ac, 0xc002da8, 0x24050080, +0x8c02025c, 0x27440224, 0xaf4201f0, 0x8c020260, +0x24050200, 0x24060008, 0xaf4201f8, 0xc002dbf, +0x0, 0x3c043b9a, 0x3484ca00, 0x3821, +0x24020006, 0x24030002, 0xaf4201f4, 0x240203e8, +0xaf430204, 0xaf430200, 0xaf4401fc, 0xaf420294, +0x24020001, 0xaf430290, 0xaf42029c, 0x3c030002, +0x671821, 0x90638438, 0x3471021, 0x24e70001, +0xa043022c, 0x2ce2000f, 0x1440fff8, 0x3471821, +0x24e70001, 0x3c080001, 0x350840f8, 0x8f820040, +0x3c040001, 0x2484727c, 0x24051400, 0x21702, +0x24420030, 0xa062022c, 0x3471021, 0xa040022c, +0x8c070218, 0x2c03021, 0x240205c8, 0xafa20010, +0xc002d3b, 0xafa80014, 0x3c040001, 0x24847288, +0x3c050000, 0x24a55f28, 0x24060010, 0x27b10030, +0x2203821, 0x27b30034, 0xc00188f, 0xafb30010, +0x3c030002, 0x8c638428, 0x1060000a, 0x408021, +0x8fa30030, 0x2405ff00, 0x8fa20034, 0x246400ff, +0x852024, 0x831823, 0x431023, 0xafa20034, +0xafa40030, 0x3c040001, 0x24847294, 0x3c050000, +0x24a54100, 0x24060108, 0x2203821, 0xc00188f, +0xafb30010, 0x409021, 0x32c20003, 0x3c010002, +0xac3285a0, 0x10400059, 0x2203821, 0x8f820050, +0x3c030010, 0x431024, 0x1040002a, 0x0, +0x8c020218, 0x30420040, 0x10400023, 0x24020001, +0x8f820050, 0x8c030218, 0x3c040001, 0x248472a0, 0xafa20010, 0xafa30014, 0x8f870040, 0x24051500, -0xc002b37, 0x2c03021, 0x10000004, 0x0, -0x3c010001, 0x370821, 0xa02240f4, 0x3c040001, -0x24845dfc, 0x3c050001, 0x24a55c00, 0x3c060001, -0x24c65c6c, 0xc53023, 0x8f420010, 0x27b30030, -0x2603821, 0x27b10034, 0x34420a00, 0xaf420010, -0xc0017a3, 0xafb10010, 0x3c040001, 0x24845e10, -0x3c050001, 0x24a5b700, 0x3c060001, 0x24c6ba7c, -0xc53023, 0x2603821, 0xaf420108, 0xc0017a3, -0xafb10010, 0x3c040001, 0x24845e2c, 0x3c050001, -0x24a5be44, 0x3c060001, 0x24c6c8ec, 0xc53023, -0x2603821, 0x3c010001, 0xac226fb4, 0xc0017a3, -0xafb10010, 0x3c040001, 0x24845e44, 0x10000024, -0x24051600, 0x3c040001, 0x24845e4c, 0x3c050001, -0x24a5a0fc, 0x3c060001, 0x24c6a228, 0xc53023, -0xc0017a3, 0xafb30010, 0x3c040001, 0x24845e5c, -0x3c050001, 0x24a5b29c, 0x3c060001, 0x24c6b6f8, -0xc53023, 0x2203821, 0xaf420108, 0xc0017a3, -0xafb30010, 0x3c040001, 0x24845e70, 0x3c050001, -0x24a5ba84, 0x3c060001, 0x24c6be3c, 0xc53023, -0x2203821, 0x3c010001, 0xac226fb4, 0xc0017a3, -0xafb30010, 0x3c040001, 0x24845e84, 0x24051650, -0x2c03021, 0x3821, 0x3c010001, 0xac226fb8, -0xafa00010, 0xc002b37, 0xafa00014, 0x32c20020, -0x10400021, 0x27a70030, 0x3c040001, 0x24845e90, -0x3c050001, 0x24a5b128, 0x3c060001, 0x24c6b294, -0xc53023, 0x24022000, 0xaf42001c, 0x27a20034, -0xc0017a3, 0xafa20010, 0x21900, 0x31982, -0x3c040800, 0x641825, 0xae430028, 0x24030010, -0xaf43003c, 0x96e30450, 0xaf430040, 0x8f430040, -0x3c040001, 0x24845ea4, 0xafa00014, 0xafa30010, -0x8f47001c, 0x24051660, 0x3c010001, 0xac226fb0, -0x10000025, 0x32c60020, 0x8ee20448, 0x8ee3044c, -0xaf43001c, 0x8f42001c, 0x2442e000, 0x2c422001, -0x1440000a, 0x240e0001, 0x3c040001, 0x24845eb0, -0xa3ae003f, 0xafa00010, 0xafa00014, 0x8f46001c, -0x24051700, 0xc002b37, 0x3821, 0x3c020000, -0x24425cbc, 0x21100, 0x21182, 0x3c030800, -0x431025, 0xae420028, 0x24020008, 0xaf42003c, -0x96e20450, 0xaf420040, 0x8f420040, 0x3c040001, -0x24845ebc, 0xafa00014, 0xafa20010, 0x8f47001c, -0x24051800, 0x32c60020, 0xc002b37, 0x0, -0x3c050fff, 0x3c030001, 0x8c636fb4, 0x34a5ffff, -0x2403021, 0x3c020001, 0x8c426fb8, 0x3c040800, -0x651824, 0x31882, 0x641825, 0x451024, -0x21082, 0x441025, 0xacc20080, 0x32c20180, -0x10400056, 0xacc30020, 0x8f82005c, 0x3c030080, -0x431024, 0x1040000d, 0x0, 0x8f820050, -0xafa20010, 0x8f82005c, 0x240e0001, 0x3c040001, -0x24845ec8, 0xa3ae003f, 0xafa20014, 0x8f870040, -0x24051900, 0xc002b37, 0x2c03021, 0x8f820050, -0x3c030010, 0x431024, 0x10400016, 0x0, -0x8c020218, 0x30420040, 0x1040000f, 0x24020001, -0x8f820050, 0x8c030218, 0x240e0001, 0x3c040001, -0x24845df0, 0xa3ae003f, 0xafa20010, 0xafa30014, -0x8f870040, 0x24052000, 0xc002b37, 0x2c03021, +0xc002d3b, 0x2c03021, 0x3c040001, 0x248471f0, +0x24020474, 0xafa20010, 0xafa00014, 0x8f860144, +0x3c070001, 0x24e771f8, 0xc002d3b, 0x3405dead, +0x8f82011c, 0x34420002, 0xaf82011c, 0x8f820220, +0x34420004, 0xaf820220, 0x8f820140, 0x240e0001, +0x3c030001, 0xa3ae003f, 0x431025, 0xaf820140, 0x10000004, 0x0, 0x3c010001, 0x370821, -0xa02240f4, 0x3c040001, 0x24845ed4, 0x3c050001, -0x24a55b80, 0x3c060001, 0x24c65bf8, 0xc53023, -0x8f420008, 0x27b30030, 0x2603821, 0x27b10034, -0x34420e00, 0xaf420008, 0xc0017a3, 0xafb10010, -0x3c040001, 0x24845eec, 0x3c050001, 0x24a5d8a0, -0x3c060001, 0x24c6e3b4, 0xc53023, 0x2603821, -0xaf42010c, 0xc0017a3, 0xafb10010, 0x3c040001, -0x24845f04, 0x3c050001, 0x24a5e998, 0x3c060001, -0x24c6f0dc, 0xc53023, 0x2603821, 0x3c010001, -0xac226fc4, 0xc0017a3, 0xafb10010, 0x3c040001, -0x24845f1c, 0x10000027, 0x24052100, 0x3c040001, -0x24845f24, 0x3c050001, 0x24a59fb8, 0x3c060001, -0x24c6a0f4, 0xc53023, 0x27b10030, 0x2203821, -0x27b30034, 0xc0017a3, 0xafb30010, 0x3c040001, -0x24845f34, 0x3c050001, 0x24a5cac0, 0x3c060001, -0x24c6d898, 0xc53023, 0x2203821, 0xaf42010c, -0xc0017a3, 0xafb30010, 0x3c040001, 0x24845f44, -0x3c050001, 0x24a5e838, 0x3c060001, 0x24c6e990, -0xc53023, 0x2203821, 0x3c010001, 0xac226fc4, -0xc0017a3, 0xafb30010, 0x3c040001, 0x24845f58, -0x24052150, 0x2c03021, 0x3821, 0x3c010001, -0xac226fd0, 0xafa00010, 0xc002b37, 0xafa00014, -0x3c110fff, 0x3c030001, 0x8c636fc4, 0x3631ffff, -0x2409821, 0x3c020001, 0x8c426fd0, 0x3c0e0800, -0x711824, 0x31882, 0x6e1825, 0x511024, -0x21082, 0x4e1025, 0xae630038, 0xae620078, -0x8c020218, 0x30420040, 0x14400004, 0x24020001, +0xa02240f4, 0x3c040001, 0x248472ac, 0x3c050001, +0x24a5a8fc, 0x3c060001, 0x24c6aa20, 0xc53023, +0x8f420010, 0x27b30030, 0x2603821, 0x27b10034, +0x34420a00, 0xaf420010, 0xc00188f, 0xafb10010, +0x3c040001, 0x248472c0, 0x3c050001, 0x24a5bfd4, +0x3c060001, 0x24c6c35c, 0xc53023, 0x2603821, +0xaf420108, 0xc00188f, 0xafb10010, 0x3c040001, +0x248472dc, 0x3c050001, 0x24a5c7fc, 0x3c060001, +0x24c6d53c, 0xc53023, 0x2603821, 0x3c010002, +0xac228614, 0xc00188f, 0xafb10010, 0x3c040001, +0x248472f4, 0x10000024, 0x24051600, 0x3c040001, +0x248472fc, 0x3c050001, 0x24a5a744, 0x3c060001, +0x24c6a8f4, 0xc53023, 0xc00188f, 0xafb30010, +0x3c040001, 0x2484730c, 0x3c050001, 0x24a5bb10, +0x3c060001, 0x24c6bfcc, 0xc53023, 0x2203821, +0xaf420108, 0xc00188f, 0xafb30010, 0x3c040001, +0x24847320, 0x3c050001, 0x24a5c364, 0x3c060001, +0x24c6c7f4, 0xc53023, 0x2203821, 0x3c010002, +0xac228614, 0xc00188f, 0xafb30010, 0x3c040001, +0x24847334, 0x24051650, 0x2c03021, 0x3821, +0x3c010002, 0xac228618, 0xafa00010, 0xc002d3b, +0xafa00014, 0x32c20020, 0x10400021, 0x27a70030, +0x3c040001, 0x24847340, 0x3c050001, 0x24a5b938, +0x3c060001, 0x24c6bb08, 0xc53023, 0x24022000, +0xaf42001c, 0x27a20034, 0xc00188f, 0xafa20010, +0x21900, 0x31982, 0x3c040800, 0x641825, +0xae430028, 0x24030010, 0xaf43003c, 0x96e30450, +0xaf430040, 0x8f430040, 0x3c040001, 0x24847354, +0xafa00014, 0xafa30010, 0x8f47001c, 0x24051660, +0x3c010002, 0xac228610, 0x10000039, 0x32c60020, +0x8ee20448, 0x8ee3044c, 0xaf43001c, 0x8f42001c, +0x2442e000, 0x2c422001, 0x1440001e, 0x24051700, +0x3c040001, 0x24847360, 0xafa00010, 0xafa00014, +0x8f46001c, 0xc002d3b, 0x3821, 0x3c040001, +0x248471f0, 0x240204dd, 0xafa20010, 0xafa00014, +0x8f860144, 0x3c070001, 0x24e771f8, 0xc002d3b, +0x3405dead, 0x8f82011c, 0x34420002, 0xaf82011c, +0x8f820220, 0x34420004, 0xaf820220, 0x8f820140, +0x240e0001, 0x3c030001, 0xa3ae003f, 0x431025, +0xaf820140, 0x3c020000, 0x24425f64, 0x21100, +0x21182, 0x3c030800, 0x431025, 0xae420028, +0x24020008, 0xaf42003c, 0x96e20450, 0xaf420040, +0x8f420040, 0x3c040001, 0x2484736c, 0xafa00014, +0xafa20010, 0x8f47001c, 0x24051800, 0x32c60020, +0xc002d3b, 0x0, 0x3c050fff, 0x3c030002, +0x8c638614, 0x34a5ffff, 0x2403021, 0x3c020002, +0x8c428618, 0x3c040800, 0x651824, 0x31882, +0x641825, 0x451024, 0x21082, 0x441025, +0xacc20080, 0x32c20180, 0x1040007e, 0xacc30020, +0x8f82005c, 0x3c030080, 0x431024, 0x10400021, +0x0, 0x8f820050, 0xafa20010, 0x8f82005c, +0x3c040001, 0x24847378, 0xafa20014, 0x8f870040, +0x24051900, 0xc002d3b, 0x2c03021, 0x3c040001, +0x248471f0, 0x240204fe, 0xafa20010, 0xafa00014, +0x8f860144, 0x3c070001, 0x24e771f8, 0xc002d3b, +0x3405dead, 0x8f82011c, 0x34420002, 0xaf82011c, +0x8f820220, 0x34420004, 0xaf820220, 0x8f820140, +0x240e0001, 0x3c030001, 0xa3ae003f, 0x431025, +0xaf820140, 0x8f820050, 0x3c030010, 0x431024, +0x1040002a, 0x0, 0x8c020218, 0x30420040, +0x10400023, 0x24020001, 0x8f820050, 0x8c030218, +0x3c040001, 0x248472a0, 0xafa20010, 0xafa30014, +0x8f870040, 0x24052000, 0xc002d3b, 0x2c03021, +0x3c040001, 0x248471f0, 0x2402050c, 0xafa20010, +0xafa00014, 0x8f860144, 0x3c070001, 0x24e771f8, +0xc002d3b, 0x3405dead, 0x8f82011c, 0x34420002, +0xaf82011c, 0x8f820220, 0x34420004, 0xaf820220, +0x8f820140, 0x240e0001, 0x3c030001, 0xa3ae003f, +0x431025, 0xaf820140, 0x10000004, 0x0, 0x3c010001, 0x370821, 0xa02240f4, 0x3c040001, -0x24845f64, 0x3c050001, 0x24a5e3bc, 0x3c060001, -0x24c6e518, 0xc53023, 0x27be0030, 0x3c03821, -0x27b50034, 0xc0017a3, 0xafb50010, 0x3c010001, -0xac226fbc, 0x511024, 0x21082, 0x3c0e0800, -0x4e1025, 0xae620050, 0x32c22000, 0x10400006, -0x3c03821, 0x3c020000, 0x24425cbc, 0x2221024, -0x1000000f, 0x21082, 0x3c040001, 0x24845f78, -0x3c050001, 0x24a5e520, 0x3c060001, 0x24c6e6d0, -0xc53023, 0xc0017a3, 0xafb50010, 0x3c010001, -0xac226fd4, 0x511024, 0x21082, 0x3c0e0800, -0x4e1025, 0xae620048, 0x32c24000, 0x10400005, -0x27a70030, 0x3c020000, 0x24425cbc, 0x1000000e, -0x21100, 0x3c040001, 0x24845f90, 0x3c050001, -0x24a5e6d8, 0x3c060001, 0x24c6e830, 0xc53023, -0x27a20034, 0xc0017a3, 0xafa20010, 0x3c010001, -0xac226fc8, 0x21100, 0x21182, 0x3c030800, -0x431025, 0xae420060, 0x3c040001, 0x24845fa8, -0x3c050001, 0x24a58230, 0x3c060001, 0x24c68650, -0xc53023, 0x27b10030, 0x2203821, 0x27b30034, -0xc0017a3, 0xafb30010, 0x3c0e0fff, 0x35ceffff, -0x3c040001, 0x24845fb4, 0x3c050000, 0x24a56468, -0x3c060000, 0x24c66588, 0xc53023, 0x2203821, -0x240f021, 0x3c010001, 0xac226f9c, 0x4e1024, -0x21082, 0x3c150800, 0x551025, 0xafae0044, -0xafc200b8, 0xc0017a3, 0xafb30010, 0x3c040001, -0x24845fc0, 0x3c050000, 0x24a56590, 0x3c060000, -0x24c66808, 0x8fae0044, 0xc53023, 0x2203821, -0x3c010001, 0xac226f90, 0x4e1024, 0x21082, -0x551025, 0xafc200e8, 0xc0017a3, 0xafb30010, -0x3c040001, 0x24845fd8, 0x3c050000, 0x24a56810, -0x3c060000, 0x24c66940, 0x8fae0044, 0xc53023, -0x2203821, 0x3c010001, 0xac226f88, 0x4e1024, -0x21082, 0x551025, 0xafc200c0, 0xc0017a3, -0xafb30010, 0x3c040001, 0x24845ff0, 0x3c050001, -0x24a5fac0, 0x3c060001, 0x24c6fb98, 0x8fae0044, -0xc53023, 0x2203821, 0x3c010001, 0xac226f94, -0x4e1024, 0x21082, 0x551025, 0xafc200c8, -0xc0017a3, 0xafb30010, 0x3c040001, 0x24845ffc, -0x3c050001, 0x24a5c92c, 0x3c060001, 0x24c6ca10, -0xc53023, 0x2203821, 0xaf420110, 0xc0017a3, -0xafb30010, 0x3c040001, 0x2484600c, 0x3c050001, -0x24a5c900, 0x3c060001, 0x24c6c924, 0xc53023, -0x2203821, 0xaf420124, 0xc0017a3, 0xafb30010, -0x3c040001, 0x2484601c, 0x3c050001, 0x24a55b40, -0x3c060001, 0x24c65b6c, 0xc53023, 0x2203821, -0xaf420120, 0xaf420114, 0xc0017a3, 0xafb30010, -0x3c040001, 0x24846028, 0x3c050001, 0x24a5f288, -0x3c060001, 0x24c6f6a4, 0xc53023, 0x2203821, -0xaf420118, 0xc0017a3, 0xafb30010, 0x8fae0044, -0x3c010001, 0xac226fd8, 0x4e1024, 0x21082, -0x551025, 0xc003fbf, 0xafc200d0, 0xc003c3c, -0x0, 0xc0027a4, 0x0, 0xac000228, -0xac00022c, 0x96e20450, 0x2442ffff, 0xaf420038, -0x96e20460, 0xaf420080, 0x32c24000, 0x14400003, -0x0, 0x96e20480, 0xaf420084, 0x96e70490, -0x50e00001, 0x24070800, 0x24e2ffff, 0xaf420088, -0xaf42007c, 0x24020800, 0x10e2000f, 0x32c24000, -0x10400003, 0x24020400, 0x10e2000b, 0x0, -0x240e0001, 0x3c040001, 0x24846038, 0xa3ae003f, +0x24847384, 0x3c050001, 0x24a5a60c, 0x3c060001, +0x24c6a73c, 0xc53023, 0x8f420008, 0x27b30030, +0x2603821, 0x27b10034, 0x34420e00, 0xaf420008, +0xc00188f, 0xafb10010, 0x3c040001, 0x2484739c, +0x3c050001, 0x24a5e8b8, 0x3c060001, 0x24c6f6e4, +0xc53023, 0x2603821, 0xaf42010c, 0xc00188f, +0xafb10010, 0x3c040001, 0x248473b4, 0x3c050001, +0x24a5fed0, 0x3c060001, 0x24c60670, 0xc53023, +0x2603821, 0x3c010002, 0xac228624, 0xc00188f, +0xafb10010, 0x3c040001, 0x248473cc, 0x10000027, +0x24052100, 0x3c040001, 0x248473d4, 0x3c050001, +0x24a5a444, 0x3c060001, 0x24c6a604, 0xc53023, +0x27b10030, 0x2203821, 0x27b30034, 0xc00188f, +0xafb30010, 0x3c040001, 0x248473e4, 0x3c050001, +0x24a5d738, 0x3c060001, 0x24c6e8b0, 0xc53023, +0x2203821, 0xaf42010c, 0xc00188f, 0xafb30010, +0x3c040001, 0x248473f4, 0x3c050001, 0x24a5fc94, +0x3c060001, 0x24c6fec8, 0xc53023, 0x2203821, +0x3c010002, 0xac228624, 0xc00188f, 0xafb30010, +0x3c040001, 0x24847408, 0x24052150, 0x2c03021, +0x3821, 0x3c010002, 0xac228630, 0xafa00010, +0xc002d3b, 0xafa00014, 0x3c110fff, 0x3c030002, +0x8c638624, 0x3631ffff, 0x2409821, 0x3c020002, +0x8c428630, 0x3c0e0800, 0x711824, 0x31882, +0x6e1825, 0x511024, 0x21082, 0x4e1025, +0xae630038, 0xae620078, 0x8c020218, 0x30420040, +0x14400004, 0x24020001, 0x3c010001, 0x370821, +0xa02240f4, 0x3c040001, 0x24847414, 0x3c050001, +0x24a5f6ec, 0x3c060001, 0x24c6f8ac, 0xc53023, +0x27be0030, 0x3c03821, 0x27b50034, 0xc00188f, +0xafb50010, 0x3c010002, 0xac22861c, 0x511024, +0x21082, 0x3c0e0800, 0x4e1025, 0xae620050, +0x32c22000, 0x10400006, 0x3c03821, 0x3c020000, +0x24425f64, 0x2221024, 0x1000000f, 0x21082, +0x3c040001, 0x24847428, 0x3c050001, 0x24a5f8b4, +0x3c060001, 0x24c6fac8, 0xc53023, 0xc00188f, +0xafb50010, 0x3c010002, 0xac228634, 0x511024, +0x21082, 0x3c0e0800, 0x4e1025, 0xae620048, +0x32c24000, 0x10400005, 0x27a70030, 0x3c020000, +0x24425f64, 0x1000000e, 0x21100, 0x3c040001, +0x24847440, 0x3c050001, 0x24a5fad0, 0x3c060001, +0x24c6fc8c, 0xc53023, 0x27a20034, 0xc00188f, +0xafa20010, 0x3c010002, 0xac228628, 0x21100, +0x21182, 0x3c030800, 0x431025, 0xae420060, +0x3c040001, 0x24847458, 0x3c050001, 0x24a5866c, +0x3c060001, 0x24c68aac, 0xc53023, 0x27b10030, +0x2203821, 0x27b30034, 0xc00188f, 0xafb30010, +0x3c0e0fff, 0x35ceffff, 0x3c040001, 0x24847464, +0x3c050000, 0x24a5687c, 0x3c060000, 0x24c6699c, +0xc53023, 0x2203821, 0x240f021, 0x3c010002, +0xac2285fc, 0x4e1024, 0x21082, 0x3c150800, +0x551025, 0xafae0044, 0xafc200b8, 0xc00188f, +0xafb30010, 0x3c040001, 0x24847470, 0x3c050000, +0x24a569a4, 0x3c060000, 0x24c66c24, 0x8fae0044, +0xc53023, 0x2203821, 0x3c010002, 0xac2285f0, +0x4e1024, 0x21082, 0x551025, 0xafc200e8, +0xc00188f, 0xafb30010, 0x3c040001, 0x24847488, +0x3c050000, 0x24a56c2c, 0x3c060000, 0x24c66d60, +0x8fae0044, 0xc53023, 0x2203821, 0x3c010002, +0xac2285e8, 0x4e1024, 0x21082, 0x551025, +0xafc200c0, 0xc00188f, 0xafb30010, 0x3c040001, +0x248474a0, 0x3c050001, 0x24a51114, 0x3c060001, +0x24c611ec, 0x8fae0044, 0xc53023, 0x2203821, +0x3c010002, 0xac2285f4, 0x4e1024, 0x21082, +0x551025, 0xafc200c8, 0xc00188f, 0xafb30010, +0x3c040001, 0x248474ac, 0x3c050001, 0x24a5d570, +0x3c060001, 0x24c6d654, 0xc53023, 0x2203821, +0xaf420110, 0xc00188f, 0xafb30010, 0x3c040001, +0x248474bc, 0x3c050001, 0x24a5d544, 0x3c060001, +0x24c6d568, 0xc53023, 0x2203821, 0xaf420124, +0xc00188f, 0xafb30010, 0x3c040001, 0x248474cc, +0x3c050001, 0x24a5d65c, 0x3c060001, 0x24c6d684, +0xc53023, 0x2203821, 0xaf420120, 0xaf420114, +0xc00188f, 0xafb30010, 0x3c040001, 0x248474d8, +0x3c050001, 0x24a5080c, 0x3c060001, 0x24c60d04, +0xc53023, 0x2203821, 0xaf420118, 0xc00188f, +0xafb30010, 0x8fae0044, 0x3c010002, 0xac228638, +0x4e1024, 0x21082, 0x551025, 0xc004553, +0xafc200d0, 0xc00419e, 0x0, 0xc0028c7, +0x0, 0xac000228, 0xac00022c, 0x96e20450, +0x2442ffff, 0xaf420038, 0x96e20460, 0xaf420080, +0x32c24000, 0x14400003, 0x0, 0x96e20480, +0xaf420084, 0x96e70490, 0x50e00001, 0x24070800, +0x24e2ffff, 0xaf420088, 0xaf42007c, 0x24020800, +0x10e20023, 0x32c24000, 0x10400003, 0x24020400, +0x10e2001f, 0x0, 0x3c040001, 0x248474e8, 0x96e60490, 0x24052170, 0x2c03821, 0xafa00010, -0xc002b37, 0xafa00014, 0x8f430138, 0x8f440138, -0x24020001, 0xa34205c2, 0xaf430094, 0xaf440098, -0xafa00010, 0xafa00014, 0x8f460080, 0x8f470084, -0x3c040001, 0x24846044, 0xc002b37, 0x24052200, -0xc0024a4, 0x3c110800, 0x3c1433d8, 0x3694cb58, -0x3c020800, 0x34420080, 0x3c040001, 0x24846050, -0x3c050000, 0x24a55d00, 0x3c060000, 0x24c65d1c, -0xc53023, 0x27a70030, 0xaf820060, 0x2402ffff, -0xaf820064, 0x27a20034, 0xc0017a3, 0xafa20010, -0x3c010001, 0xac226f78, 0x21100, 0x21182, -0x511025, 0xc0018fc, 0xae420000, 0x8f820240, -0x3c030001, 0x431025, 0xaf820240, 0x3c020000, -0x24424034, 0xaf820244, 0xaf800240, 0x8f820060, -0x511024, 0x14400005, 0x3c030800, 0x8f820060, -0x431024, 0x1040fffd, 0x0, 0xc003c49, -0x8821, 0x3c020100, 0xafa20020, 0x8f530018, -0x240200ff, 0x56620001, 0x26710001, 0x8c020228, +0xc002d3b, 0xafa00014, 0x3c040001, 0x248471f0, +0x240205f1, 0xafa20010, 0xafa00014, 0x8f860144, +0x3c070001, 0x24e771f8, 0xc002d3b, 0x3405dead, +0x8f82011c, 0x34420002, 0xaf82011c, 0x8f820220, +0x34420004, 0xaf820220, 0x8f820140, 0x240e0001, +0x3c030001, 0xa3ae003f, 0x431025, 0xaf820140, +0x8f430138, 0x8f440138, 0x24020001, 0xa34205c2, +0xaf430094, 0xaf440098, 0xafa00010, 0xafa00014, +0x8f460080, 0x8f470084, 0x3c040001, 0x248474f4, +0xc002d3b, 0x24052200, 0xc0025c6, 0x3c110800, +0x3c1433d8, 0x3694cb58, 0x3c020800, 0x34420080, +0x3c040001, 0x24847500, 0x3c050000, 0x24a55ff8, +0x3c060000, 0x24c66014, 0xc53023, 0x27a70030, +0xaf820060, 0x2402ffff, 0xaf820064, 0x27a20034, +0xc00188f, 0xafa20010, 0x3c010002, 0xac2285d8, +0x21100, 0x21182, 0x511025, 0xc0019e8, +0xae420000, 0x8f820240, 0x3c030001, 0x431025, +0xaf820240, 0x3c020000, 0x24424034, 0xaf820244, +0xaf800240, 0x8f820060, 0x511024, 0x14400005, +0x3c030800, 0x8f820060, 0x431024, 0x1040fffd, +0x0, 0xc0041ab, 0x8821, 0x3c020100, +0xafa20020, 0x8f530018, 0x240200ff, 0x56620001, +0x26710001, 0x8c020228, 0x1622000e, 0x1330c0, +0x8f42033c, 0x24420001, 0xaf42033c, 0x8f42033c, +0x8c020228, 0x3c040001, 0x24847194, 0x3c050009, +0xafa00014, 0xafa20010, 0x8fa60020, 0x1000003f, +0x34a50100, 0xd71021, 0x8fa30020, 0x8fa40024, +0xac4304c0, 0xac4404c4, 0xc01821, 0x8f440178, +0x8f45017c, 0x1021, 0x24070004, 0xafa70010, +0xafb10014, 0x8f48000c, 0x24c604c0, 0x2e63021, +0xafa80018, 0x8f48010c, 0x24070008, 0xa32821, +0xa3482b, 0x822021, 0x100f809, 0x892021, +0x1440000b, 0x24070008, 0x8f820120, 0xafa20010, +0x8f820124, 0x3c040001, 0x2484719c, 0x3c050009, +0xafa20014, 0x8fa60020, 0x1000001c, 0x34a50200, +0x8f440160, 0x8f450164, 0x8f43000c, 0xaf510018, +0x8f860120, 0x24020010, 0xafa20010, 0xafb10014, +0xafa30018, 0x8f42010c, 0x40f809, 0x24c6001c, +0x14400010, 0x0, 0x8f420340, 0x24420001, +0xaf420340, 0x8f420340, 0x8f820120, 0xafa20010, +0x8f820124, 0x3c040001, 0x248471a4, 0x3c050009, +0xafa20014, 0x8fa60020, 0x34a50300, 0xc002d3b, +0x2603821, 0x8f4202e4, 0x24420001, 0xaf4202e4, +0x8f4202e4, 0x93a2003f, 0x1040007d, 0x3c020700, +0x34423000, 0xafa20028, 0x8f530018, 0x240200ff, +0x12620002, 0x8821, 0x26710001, 0x8c020228, 0x1622000e, 0x1330c0, 0x8f42033c, 0x24420001, 0xaf42033c, 0x8f42033c, 0x8c020228, 0x3c040001, -0x24845ce4, 0x3c050009, 0xafa00014, 0xafa20010, -0x8fa60020, 0x1000003f, 0x34a50100, 0xd71021, -0x8fa30020, 0x8fa40024, 0xac4304c0, 0xac4404c4, +0x24847194, 0x3c050009, 0xafa00014, 0xafa20010, +0x8fa60028, 0x1000003f, 0x34a50100, 0xd71021, +0x8fa30028, 0x8fa4002c, 0xac4304c0, 0xac4404c4, 0xc01821, 0x8f440178, 0x8f45017c, 0x1021, 0x24070004, 0xafa70010, 0xafb10014, 0x8f48000c, 0x24c604c0, 0x2e63021, 0xafa80018, 0x8f48010c, 0x24070008, 0xa32821, 0xa3482b, 0x822021, 0x100f809, 0x892021, 0x1440000b, 0x24070008, 0x8f820120, 0xafa20010, 0x8f820124, 0x3c040001, -0x24845cec, 0x3c050009, 0xafa20014, 0x8fa60020, +0x2484719c, 0x3c050009, 0xafa20014, 0x8fa60028, 0x1000001c, 0x34a50200, 0x8f440160, 0x8f450164, 0x8f43000c, 0xaf510018, 0x8f860120, 0x24020010, 0xafa20010, 0xafb10014, 0xafa30018, 0x8f42010c, 0x40f809, 0x24c6001c, 0x14400010, 0x0, 0x8f420340, 0x24420001, 0xaf420340, 0x8f420340, 0x8f820120, 0xafa20010, 0x8f820124, 0x3c040001, -0x24845cf4, 0x3c050009, 0xafa20014, 0x8fa60020, -0x34a50300, 0xc002b37, 0x2603821, 0x8f4202e4, -0x24420001, 0xaf4202e4, 0x8f4202e4, 0x93a2003f, -0x10400069, 0x3c020700, 0x34423000, 0xafa20028, -0x8f530018, 0x240200ff, 0x12620002, 0x8821, -0x26710001, 0x8c020228, 0x1622000e, 0x1330c0, -0x8f42033c, 0x24420001, 0xaf42033c, 0x8f42033c, -0x8c020228, 0x3c040001, 0x24845ce4, 0x3c050009, -0xafa00014, 0xafa20010, 0x8fa60028, 0x1000003f, -0x34a50100, 0xd71021, 0x8fa30028, 0x8fa4002c, -0xac4304c0, 0xac4404c4, 0xc01821, 0x8f440178, -0x8f45017c, 0x1021, 0x24070004, 0xafa70010, -0xafb10014, 0x8f48000c, 0x24c604c0, 0x2e63021, -0xafa80018, 0x8f48010c, 0x24070008, 0xa32821, -0xa3482b, 0x822021, 0x100f809, 0x892021, -0x1440000b, 0x24070008, 0x8f820120, 0xafa20010, -0x8f820124, 0x3c040001, 0x24845cec, 0x3c050009, -0xafa20014, 0x8fa60028, 0x1000001c, 0x34a50200, -0x8f440160, 0x8f450164, 0x8f43000c, 0xaf510018, -0x8f860120, 0x24020010, 0xafa20010, 0xafb10014, -0xafa30018, 0x8f42010c, 0x40f809, 0x24c6001c, -0x14400010, 0x0, 0x8f420340, 0x24420001, -0xaf420340, 0x8f420340, 0x8f820120, 0xafa20010, -0x8f820124, 0x3c040001, 0x24845cf4, 0x3c050009, -0xafa20014, 0x8fa60028, 0x34a50300, 0xc002b37, -0x2603821, 0x8f4202f0, 0x24420001, 0xaf4202f0, -0x8f4202f0, 0x3c040001, 0x24846060, 0xafa00010, -0xafa00014, 0x8fa60028, 0x24052300, 0xc002b37, -0x3821, 0x10000004, 0x0, 0x8c020264, -0x10400005, 0x0, 0x8f8200a0, 0x30420004, -0x1440fffa, 0x0, 0x8f820044, 0x34420004, -0xaf820044, 0x8f420308, 0x24420001, 0xaf420308, -0x8f420308, 0x8f8200d8, 0x8f8300d4, 0x431023, -0x2442ff80, 0xaf420090, 0x8f420090, 0x2842ff81, -0x10400006, 0x24020001, 0x8f420090, 0x8f430144, -0x431021, 0xaf420090, 0x24020001, 0xaf42008c, -0x32c20008, 0x10400006, 0x0, 0x8f820214, -0x3c038100, 0x3042ffff, 0x431025, 0xaf820214, -0x3c030001, 0x8c636e54, 0x30620002, 0x10400009, -0x30620001, 0x3c040001, 0x2484606c, 0x3c050000, -0x24a56d50, 0x3c060000, 0x24c671c8, 0x10000012, -0xc53023, 0x10400009, 0x0, 0x3c040001, -0x2484607c, 0x3c050000, 0x24a571d0, 0x3c060000, -0x24c67678, 0x10000008, 0xc53023, 0x3c040001, -0x2484608c, 0x3c050000, 0x24a56948, 0x3c060000, -0x24c66d48, 0xc53023, 0x27a70030, 0x27a20034, -0xc0017a3, 0xafa20010, 0x3c010001, 0xac226f8c, -0x3c020001, 0x8c426f8c, 0x3c030800, 0x21100, -0x21182, 0x431025, 0xae420040, 0x8f8200a0, -0xafa20010, 0x8f8200b0, 0xafa20014, 0x8f86005c, -0x8f87011c, 0x3c040001, 0x2484609c, 0x3c010001, -0xac366f64, 0x3c010001, 0xac206f54, 0x3c010001, -0xac3c6f4c, 0x3c010001, 0xac3b6f7c, 0x3c010001, -0xac376f80, 0x3c010001, 0xac3a6f60, 0xc002b37, -0x24052400, 0x8f820200, 0xafa20010, 0x8f820220, -0xafa20014, 0x8f860044, 0x8f870050, 0x3c040001, -0x248460a8, 0xc002b37, 0x24052500, 0x8f830060, -0x74100b, 0x242000a, 0x200f821, 0x0, -0xd, 0x8fbf0060, 0x8fbe005c, 0x8fb50058, -0x8fb30054, 0x8fb20050, 0x8fb1004c, 0x8fb00048, -0x3e00008, 0x27bd0068, 0x27bdffe0, 0x3c040001, -0x248460b4, 0x24052600, 0x3021, 0x3821, -0xafbf0018, 0xafa00010, 0xc002b37, 0xafa00014, -0x8fbf0018, 0x3e00008, 0x27bd0020, 0x3e00008, -0x0, 0x3e00008, 0x0, 0x0, +0x248471a4, 0x3c050009, 0xafa20014, 0x8fa60028, +0x34a50300, 0xc002d3b, 0x2603821, 0x8f4202f0, +0x24420001, 0xaf4202f0, 0x8f4202f0, 0x3c040001, +0x24847510, 0xafa00010, 0xafa00014, 0x8fa60028, +0x24052300, 0xc002d3b, 0x3821, 0x3c040001, +0x248471f0, 0x24020656, 0xafa20010, 0xafa00014, +0x8f860144, 0x3c070001, 0x24e771f8, 0xc002d3b, +0x3405dead, 0x8f82011c, 0x34420002, 0xaf82011c, +0x8f820220, 0x34420004, 0xaf820220, 0x8f820140, +0x3c030001, 0x431025, 0xaf820140, 0x10000004, +0x0, 0x8c020264, 0x10400005, 0x0, +0x8f8200a0, 0x30420004, 0x1440fffa, 0x0, +0x8f820044, 0x34420004, 0xaf820044, 0x8f420308, +0x24420001, 0xaf420308, 0x8f420308, 0x8f8200d8, +0x8f8300d4, 0x431023, 0x2442ff80, 0xaf420090, +0x8f420090, 0x2842ff81, 0x10400006, 0x24020001, +0x8f420090, 0x8f430144, 0x431021, 0xaf420090, +0x24020001, 0xaf42008c, 0x32c20008, 0x10400006, +0x0, 0x8f820214, 0x3c038100, 0x3042ffff, +0x431025, 0xaf820214, 0x3c030002, 0x8c6384c8, +0x30620002, 0x10400009, 0x30620001, 0x3c040001, +0x2484751c, 0x3c050000, 0x24a57174, 0x3c060000, +0x24c675f8, 0x10000012, 0xc53023, 0x10400009, +0x0, 0x3c040001, 0x2484752c, 0x3c050000, +0x24a57600, 0x3c060000, 0x24c67aa8, 0x10000008, +0xc53023, 0x3c040001, 0x2484753c, 0x3c050000, +0x24a56d68, 0x3c060000, 0x24c6716c, 0xc53023, +0x27a70030, 0x27a20034, 0xc00188f, 0xafa20010, +0x3c010002, 0xac2285ec, 0x3c020002, 0x8c4285ec, +0x3c030800, 0x21100, 0x21182, 0x431025, +0xae420040, 0x8f8200a0, 0xafa20010, 0x8f8200b0, +0xafa20014, 0x8f86005c, 0x8f87011c, 0x3c040001, +0x2484754c, 0x3c010002, 0xac3685c4, 0x3c010002, +0xac2085b4, 0x3c010002, 0xac3c85ac, 0x3c010002, +0xac3b85dc, 0x3c010002, 0xac3785e0, 0x3c010002, +0xac3a85c0, 0xc002d3b, 0x24052400, 0x8f820200, +0xafa20010, 0x8f820220, 0xafa20014, 0x8f860044, +0x8f870050, 0x3c040001, 0x24847558, 0xc002d3b, +0x24052500, 0x8f830060, 0x74100b, 0x242000a, +0x200f821, 0x0, 0xd, 0x8fbf0060, +0x8fbe005c, 0x8fb50058, 0x8fb30054, 0x8fb20050, +0x8fb1004c, 0x8fb00048, 0x3e00008, 0x27bd0068, +0x27bdffe0, 0x3c040001, 0x24847564, 0x24052600, +0x3021, 0x3821, 0xafbf0018, 0xafa00010, +0xc002d3b, 0xafa00014, 0x3c040001, 0x248471f0, +0x240206bb, 0xafa20010, 0xafa00014, 0x8f860144, +0x3c070001, 0x24e771f8, 0xc002d3b, 0x3405dead, +0x8f82011c, 0x34420002, 0xaf82011c, 0x8f820220, +0x34420004, 0xaf820220, 0x8f820140, 0x3c030001, +0x431025, 0xaf820140, 0x8fbf0018, 0x3e00008, +0x27bd0020, 0x3e00008, 0x0, 0x3e00008, 0x0, 0x0, 0x0, 0x0, -0x3e00008, 0x0, 0x3e00008, 0x0, -0x27bdfde0, 0x27a50018, 0x3c04dead, 0x3484beef, -0xafbf0218, 0x8f820150, 0x3c03001f, 0x3463ffff, -0xafa40018, 0xa22823, 0xa32824, 0x8ca20000, -0x1044000a, 0x0, 0xafa50010, 0x8ca20000, -0xafa20014, 0x8f860150, 0x8f870250, 0x3c040001, -0x248460bc, 0xc002b37, 0x24052700, 0x8fbf0218, +0x0, 0x0, 0x3e00008, 0x0, +0x3e00008, 0x0, 0x27bdfde0, 0xafb00218, +0x27b00018, 0x3c0200bf, 0x3442ffff, 0x50102b, +0x10400015, 0xafbf021c, 0x3c040001, 0x248471f0, +0x240206df, 0xafa20010, 0xafa00014, 0x8f860144, +0x3c070001, 0x24e771f8, 0xc002d3b, 0x3405dead, +0x8f82011c, 0x34420002, 0xaf82011c, 0x8f820220, +0x34420004, 0xaf820220, 0x8f820140, 0x3c030001, +0x431025, 0xaf820140, 0x3c04dead, 0x3484beef, +0x8f820150, 0x3c03001f, 0x3463ffff, 0xafa40018, +0x2028023, 0x2038024, 0x8e020000, 0x1044001e, +0x0, 0xafb00010, 0x8e020000, 0xafa20014, +0x8f860150, 0x8f870250, 0x3c040001, 0x2484756c, +0xc002d3b, 0x24052700, 0x3c040001, 0x248471f0, +0x240206ed, 0xafa20010, 0xafa00014, 0x8f860144, +0x3c070001, 0x24e771f8, 0xc002d3b, 0x3405dead, +0x8f82011c, 0x34420002, 0xaf82011c, 0x8f820220, +0x34420004, 0xaf820220, 0x8f820140, 0x3c030001, +0x431025, 0xaf820140, 0x8fbf021c, 0x8fb00218, 0x3e00008, 0x27bd0220, 0x27bdffe0, 0x3c06abba, 0x34c6babe, 0xafb00018, 0x3c100004, 0x3c07007f, 0x34e7ffff, 0xafbf001c, 0x102840, 0x8e040000, 0x8ca30000, 0xaca00000, 0xae060000, 0x8ca20000, 0xaca30000, 0x10460005, 0xae040000, 0xa08021, 0xf0102b, 0x1040fff5, 0x102840, 0x3c040001, -0x248460c8, 0x24052800, 0x2003021, 0x3821, -0xafa00010, 0xc002b37, 0xafa00014, 0x2001021, +0x24847578, 0x24052800, 0x2003021, 0x3821, +0xafa00010, 0xc002d3b, 0xafa00014, 0x2001021, 0x8fbf001c, 0x8fb00018, 0x3e00008, 0x27bd0020, 0x8c020224, 0x3047003f, 0x10e00010, 0x803021, 0x2821, 0x24030020, 0xe31024, 0x10400002, @@ -519,313 +572,321 @@ 0x8ea20000, 0x2403fffc, 0xc38024, 0x50102b, 0x1440001b, 0xe08821, 0x8e330000, 0xafb00010, 0x8ea20000, 0xafa20014, 0x8e270000, 0x24053000, -0xc002b37, 0x2403021, 0x8e230000, 0x702021, +0xc002d3b, 0x2403021, 0x8e230000, 0x702021, 0x64102b, 0x10400007, 0x2402821, 0x8ca20000, 0xac620000, 0x24630004, 0x64102b, 0x1440fffb, 0x24a50004, 0x8ea20000, 0x501023, 0xaea20000, 0x8e220000, 0x501021, 0x1000000b, 0xae220000, 0x2402002d, 0xa0820000, 0xafb00010, 0x8ea20000, 0x2409821, 0xafa20014, 0x8e270000, 0x24053100, -0xc002b37, 0x2603021, 0x2601021, 0x8fbf002c, +0xc002d3b, 0x2603021, 0x2601021, 0x8fbf002c, 0x8fb50028, 0x8fb30024, 0x8fb20020, 0x8fb1001c, 0x8fb00018, 0x3e00008, 0x27bd0030, 0x27bdffe8, -0x3c1cc000, 0x3c05fffe, 0x3c030001, 0x8c636f44, -0x3c040001, 0x8c846f50, 0x34a5bf08, 0x24021ffc, -0x3c010001, 0xac226d90, 0x3c0200c0, 0x3c010001, -0xac226d94, 0x3c020020, 0xafbf0010, 0x3c0100c0, +0x3c1cc000, 0x3c05fffe, 0x3c030002, 0x8c6385a4, +0x3c040002, 0x8c8485b0, 0x34a5bf08, 0x24021ffc, +0x3c010002, 0xac228430, 0x3c0200c0, 0x3c010002, +0xac228434, 0x3c020020, 0xafbf0010, 0x3c0100c0, 0xac201ffc, 0x431023, 0x441023, 0x245bb000, -0x365b821, 0x3c1d0001, 0x8fbd6d8c, 0x3a0f021, +0x365b821, 0x3c1d0002, 0x8fbd842c, 0x3a0f021, 0x3c0400c0, 0x34840200, 0x3c1a00c0, 0x3c0300c0, -0x346307c8, 0x24021dfc, 0x3c010001, 0xac226d90, -0x24021834, 0x3c010001, 0xac246d94, 0x3c010001, -0xac226d90, 0x3c010001, 0xac236d94, 0xc00180d, +0x346307c8, 0x24021dfc, 0x3c010002, 0xac228430, +0x24021834, 0x3c010002, 0xac248434, 0x3c010002, +0xac228430, 0x3c010002, 0xac238434, 0xc0018f9, 0x375a0200, 0x8fbf0010, 0x3e00008, 0x27bd0018, -0x27bdffc8, 0x3c040001, 0x248460d4, 0x24053200, -0x3c020001, 0x8c426d90, 0x3c030001, 0x8c636d94, +0x27bdffc8, 0x3c040001, 0x24847584, 0x24053200, +0x3c020002, 0x8c428430, 0x3c030002, 0x8c638434, 0x3021, 0x3603821, 0xafbf0030, 0xafb3002c, 0xafb20028, 0xafb10024, 0xafb00020, 0xafa2001c, -0xafa30018, 0xafb70010, 0xc002b37, 0xafba0014, -0xc001916, 0x0, 0x8f820240, 0x34420004, +0xafa30018, 0xafb70010, 0xc002d3b, 0xafba0014, +0xc001a1b, 0x0, 0x8f820240, 0x34420004, 0xaf820240, 0x24020001, 0xaf420000, 0x3c020001, -0x571021, 0x904240f4, 0x10400092, 0x2403fffc, -0x3c100001, 0x2610ac63, 0x3c120001, 0x2652a83c, +0x571021, 0x904240f4, 0x10400093, 0x2403fffc, +0x3c100001, 0x2610b47b, 0x3c120001, 0x2652b044, 0x2121023, 0x438024, 0x8fa3001c, 0x3c040001, -0x248460e0, 0x70102b, 0x1440001a, 0x27b30018, +0x24847590, 0x70102b, 0x1440001a, 0x27b30018, 0x8fb10018, 0x24053000, 0x2403021, 0xafb00010, -0xafa30014, 0xc002b37, 0x2203821, 0x8fa30018, +0xafa30014, 0xc002d3b, 0x2203821, 0x8fa30018, 0x702021, 0x64102b, 0x10400007, 0x2403021, 0x8cc20000, 0xac620000, 0x24630004, 0x64102b, 0x1440fffb, 0x24c60004, 0x8fa2001c, 0x501023, 0xafa2001c, 0x8e620000, 0x501021, 0x1000000a, 0xae620000, 0x2408821, 0x24053100, 0xafb00010, 0xafa30014, 0x8fa70018, 0x2203021, 0x2402002d, -0xc002b37, 0xa0820000, 0x24070020, 0x8fa3001c, -0x3c040001, 0x248460fc, 0x24120020, 0x3c010001, -0xac316f70, 0x2c620020, 0x1440001d, 0x27b10018, -0x8fb00018, 0x24053000, 0x3c060001, 0x24c67010, -0xafa70010, 0xafa30014, 0xc002b37, 0x2003821, -0x8fa30018, 0x3c040001, 0x24847010, 0x24650020, +0xc002d3b, 0xa0820000, 0x24070020, 0x8fa3001c, +0x3c040001, 0x248475ac, 0x24120020, 0x3c010002, +0xac3185d0, 0x2c620020, 0x1440001d, 0x27b10018, +0x8fb00018, 0x24053000, 0x3c060002, 0x24c68670, +0xafa70010, 0xafa30014, 0xc002d3b, 0x2003821, +0x8fa30018, 0x3c040002, 0x24848670, 0x24650020, 0x65102b, 0x10400007, 0x0, 0x8c820000, 0xac620000, 0x24630004, 0x65102b, 0x1440fffb, 0x24840004, 0x8fa2001c, 0x521023, 0xafa2001c, 0x8e220000, 0x521021, 0x1000000b, 0xae220000, -0x3c100001, 0x26107010, 0x24053100, 0xafa70010, +0x3c100002, 0x26108670, 0x24053100, 0xafa70010, 0xafa30014, 0x8fa70018, 0x2003021, 0x2402002d, -0xc002b37, 0xa0820000, 0x24070020, 0x3c040001, -0x24846110, 0x8fa3001c, 0x24120020, 0x3c010001, -0xac306fa4, 0x2c620020, 0x1440001d, 0x27b10018, -0x8fb00018, 0x24053000, 0x3c060001, 0x24c67030, -0xafa70010, 0xafa30014, 0xc002b37, 0x2003821, -0x8fa30018, 0x3c040001, 0x24847030, 0x24650020, +0xc002d3b, 0xa0820000, 0x24070020, 0x3c040001, +0x248475c0, 0x8fa3001c, 0x24120020, 0x3c010002, +0xac308604, 0x2c620020, 0x1440001d, 0x27b10018, +0x8fb00018, 0x24053000, 0x3c060002, 0x24c68690, +0xafa70010, 0xafa30014, 0xc002d3b, 0x2003821, +0x8fa30018, 0x3c040002, 0x24848690, 0x24650020, 0x65102b, 0x10400007, 0x0, 0x8c820000, 0xac620000, 0x24630004, 0x65102b, 0x1440fffb, 0x24840004, 0x8fa2001c, 0x521023, 0xafa2001c, 0x8e220000, 0x521021, 0x1000000b, 0xae220000, -0x3c100001, 0x26107030, 0x24053100, 0xafa70010, +0x3c100002, 0x26108690, 0x24053100, 0xafa70010, 0xafa30014, 0x8fa70018, 0x2003021, 0x2402002d, -0xc002b37, 0xa0820000, 0x3c010001, 0x10000031, -0xac306fa0, 0x3c100001, 0x2610821f, 0x3c120001, -0x2652809c, 0x2121023, 0x438024, 0x8fa3001c, -0x3c040001, 0x24846124, 0x70102b, 0x1440001a, -0x27b30018, 0x8fb10018, 0x24053000, 0x2403021, -0xafb00010, 0xafa30014, 0xc002b37, 0x2203821, -0x8fa30018, 0x702021, 0x64102b, 0x10400007, -0x2403021, 0x8cc20000, 0xac620000, 0x24630004, -0x64102b, 0x1440fffb, 0x24c60004, 0x8fa2001c, -0x501023, 0xafa2001c, 0x8e620000, 0x501021, -0x1000000a, 0xae620000, 0x2408821, 0x24053100, -0xafb00010, 0xafa30014, 0x8fa70018, 0x2203021, -0x2402002d, 0xc002b37, 0xa0820000, 0x3c010001, -0xac316f70, 0x3c030001, 0x8c636f70, 0x24020400, -0x60f809, 0xaf820070, 0x8fbf0030, 0x8fb3002c, -0x8fb20028, 0x8fb10024, 0x8fb00020, 0x3e00008, -0x27bd0038, 0x0, 0x0, 0x8f820040, -0x3c03f000, 0x431024, 0x3c036000, 0x14430006, -0x0, 0x8f820050, 0x2403ff80, 0x431024, -0x34420055, 0xaf820050, 0x8f820054, 0x244203e8, -0xaf820058, 0x240201f4, 0xaf4200e0, 0x24020004, -0xaf4200e8, 0x24020002, 0xaf4001b0, 0xaf4000e4, -0xaf4200dc, 0xaf4000d8, 0xaf4000d4, 0x3e00008, -0xaf4000d0, 0x8f820054, 0x24420005, 0x3e00008, -0xaf820078, 0x27bdffe8, 0xafbf0010, 0x8f820054, -0x244203e8, 0xaf820058, 0x3c020800, 0x2c21024, -0x10400004, 0x3c02f7ff, 0x3442ffff, 0x2c2b024, -0x36940040, 0x3c020001, 0x8c426e68, 0x10400017, -0x3c020200, 0x3c030001, 0x8c636fdc, 0x10600016, -0x282a025, 0x3c020001, 0x8c426f04, 0x14400012, -0x3c020200, 0x3c020001, 0x8c426e54, 0x30420003, -0x1440000d, 0x3c020200, 0x8f830224, 0x3c020002, -0x8c4290ac, 0x10620008, 0x3c020200, 0xc003dab, -0x0, 0x10000004, 0x3c020200, 0xc004192, -0x0, 0x3c020200, 0x2c21024, 0x10400003, -0x0, 0xc001f4b, 0x0, 0x8f4200d8, -0x8f4300dc, 0x24420001, 0xaf4200d8, 0x43102b, -0x14400003, 0x0, 0xaf4000d8, 0x36940080, -0x8c030238, 0x1060000c, 0x0, 0x8f4201b0, -0x244203e8, 0xaf4201b0, 0x43102b, 0x14400006, -0x0, 0x934205c5, 0x14400003, 0x0, -0xc001da0, 0x0, 0x8fbf0010, 0x3e00008, -0x27bd0018, 0x3e00008, 0x0, 0x27bdffd8, -0xafbf0020, 0x8f43002c, 0x8f420038, 0x10620059, -0x0, 0x3c020001, 0x571021, 0x904240f0, -0x10400026, 0x24070008, 0x8f440170, 0x8f450174, -0x8f48000c, 0x8f860120, 0x24020020, 0xafa20010, -0xafa30014, 0xafa80018, 0x8f42010c, 0x40f809, -0x24c6001c, 0x14400011, 0x24020001, 0x3c010001, -0x370821, 0xa02240f0, 0x8f820124, 0xafa20010, -0x8f820128, 0x3c040001, 0x248461c8, 0xafa20014, -0x8f46002c, 0x8f870120, 0x3c050009, 0xc002b37, -0x34a50900, 0x1000005c, 0x0, 0x8f420300, -0x24420001, 0xaf420300, 0x8f420300, 0x8f42002c, -0xa34005c1, 0x10000027, 0xaf420038, 0x8f440170, -0x8f450174, 0x8f43002c, 0x8f48000c, 0x8f860120, -0x24020080, 0xafa20010, 0xafa30014, 0xafa80018, -0x8f42010c, 0x40f809, 0x24c6001c, 0x14400011, -0x24020001, 0x3c010001, 0x370821, 0xa02240f1, -0x8f820124, 0xafa20010, 0x8f820128, 0x3c040001, -0x248461d4, 0xafa20014, 0x8f46002c, 0x8f870120, -0x3c050009, 0xc002b37, 0x34a51100, 0x10000036, -0x0, 0x8f420300, 0x8f43002c, 0x24420001, -0xaf420300, 0x8f420300, 0x24020001, 0xa34205c1, -0xaf430038, 0x3c010001, 0x370821, 0xa02040f1, -0x3c010001, 0x370821, 0xa02040f0, 0x10000026, -0xaf400034, 0x934205c1, 0x1040001d, 0x0, -0xa34005c1, 0x8f820040, 0x30420001, 0x14400008, -0x2021, 0x8c030104, 0x24020001, 0x50620005, -0x24040001, 0x8c020264, 0x10400003, 0x801021, -0x24040001, 0x801021, 0x10400006, 0x0, -0x8f42030c, 0x24420001, 0xaf42030c, 0x10000008, -0x8f42030c, 0x8f820044, 0x34420004, 0xaf820044, -0x8f420308, 0x24420001, 0xaf420308, 0x8f420308, -0x3c010001, 0x370821, 0xa02040f0, 0x3c010001, -0x370821, 0xa02040f1, 0x8f420000, 0x10400007, -0x0, 0xaf80004c, 0x8f82004c, 0x1040fffd, -0x0, 0x10000005, 0x0, 0xaf800048, -0x8f820048, 0x1040fffd, 0x0, 0x8f820060, -0x3c03ff7f, 0x3463ffff, 0x431024, 0xaf820060, -0x8f420000, 0x10400003, 0x0, 0x10000002, -0xaf80004c, 0xaf800048, 0x8fbf0020, 0x3e00008, -0x27bd0028, 0x3e00008, 0x0, 0x27bdffd8, -0xafbf0020, 0x8f430044, 0x8f42007c, 0x10620029, -0x24070008, 0x8f440168, 0x8f45016c, 0x8f48000c, -0x8f860120, 0x24020040, 0xafa20010, 0xafa30014, +0xc002d3b, 0xa0820000, 0x3c010002, 0xac308600, +0x10000031, 0x0, 0x3c100001, 0x26108667, +0x3c120001, 0x265284d8, 0x2121023, 0x438024, +0x8fa3001c, 0x3c040001, 0x248475d4, 0x70102b, +0x1440001a, 0x27b30018, 0x8fb10018, 0x24053000, +0x2403021, 0xafb00010, 0xafa30014, 0xc002d3b, +0x2203821, 0x8fa30018, 0x702021, 0x64102b, +0x10400007, 0x2403021, 0x8cc20000, 0xac620000, +0x24630004, 0x64102b, 0x1440fffb, 0x24c60004, +0x8fa2001c, 0x501023, 0xafa2001c, 0x8e620000, +0x501021, 0x1000000a, 0xae620000, 0x2408821, +0x24053100, 0xafb00010, 0xafa30014, 0x8fa70018, +0x2203021, 0x2402002d, 0xc002d3b, 0xa0820000, +0x3c010002, 0xac3185d0, 0x3c030002, 0x8c6385d0, +0x24020400, 0xaf820070, 0x60f809, 0x0, +0x8fbf0030, 0x8fb3002c, 0x8fb20028, 0x8fb10024, +0x8fb00020, 0x3e00008, 0x27bd0038, 0x27bdffe0, +0xafbf0018, 0x8f820040, 0x3c03f000, 0x431024, +0x3c036000, 0x14430008, 0x240201f9, 0x8f820050, +0x2403ff80, 0x431024, 0x34420055, 0xaf820050, +0x10000014, 0x0, 0x3c040001, 0x24847694, +0xafa20010, 0xafa00014, 0x8f860144, 0x3c070001, +0x24e776a4, 0xc002d3b, 0x3405dead, 0x8f82011c, +0x34420002, 0xaf82011c, 0x8f820220, 0x34420004, +0xaf820220, 0x8f820140, 0x3c030001, 0x431025, +0xaf820140, 0x8f820054, 0x244203e8, 0xaf820058, +0x240201f4, 0xaf4200e0, 0x24020004, 0xaf4200e8, +0x24020002, 0xaf4001b0, 0xaf4000e4, 0xaf4200dc, +0xaf4000d8, 0xaf4000d4, 0x8fbf0018, 0xaf4000d0, +0x3e00008, 0x27bd0020, 0x8f820054, 0x24420005, +0x3e00008, 0xaf820078, 0x27bdffe8, 0xafbf0010, +0x8f820054, 0x244203e8, 0xaf820058, 0x3c020800, +0x2c21024, 0x10400004, 0x3c02f7ff, 0x3442ffff, +0x2c2b024, 0x36940040, 0x3c020002, 0x8c4284dc, +0x10400017, 0x3c020200, 0x3c030002, 0x8c63863c, +0x10600016, 0x282a025, 0x3c020002, 0x8c428568, +0x14400012, 0x3c020200, 0x3c020002, 0x8c4284c8, +0x30420003, 0x1440000d, 0x3c020200, 0x8f830224, +0x3c020002, 0x8c42a70c, 0x10620008, 0x3c020200, +0xc004343, 0x0, 0x10000004, 0x3c020200, +0xc00474b, 0x0, 0x3c020200, 0x2c21024, +0x10400003, 0x0, 0xc002058, 0x0, +0x8f4200d8, 0x8f4300dc, 0x24420001, 0xaf4200d8, +0x43102b, 0x14400003, 0x0, 0xaf4000d8, +0x36940080, 0x8c030238, 0x1060000c, 0x0, +0x8f4201b0, 0x244203e8, 0xaf4201b0, 0x43102b, +0x14400006, 0x0, 0x934205c5, 0x14400003, +0x0, 0xc001eac, 0x0, 0x8fbf0010, +0x3e00008, 0x27bd0018, 0x3e00008, 0x0, +0x27bdffd8, 0xafbf0020, 0x8f43002c, 0x8f420038, +0x10620059, 0x0, 0x3c020001, 0x571021, +0x904240f0, 0x10400026, 0x24070008, 0x8f440170, +0x8f450174, 0x8f48000c, 0x8f860120, 0x24020020, +0xafa20010, 0xafa30014, 0xafa80018, 0x8f42010c, +0x40f809, 0x24c6001c, 0x14400011, 0x24020001, +0x3c010001, 0x370821, 0xa02240f0, 0x8f820124, +0xafa20010, 0x8f820128, 0x3c040001, 0x24847678, +0xafa20014, 0x8f46002c, 0x8f870120, 0x3c050009, +0xc002d3b, 0x34a50900, 0x1000005d, 0x0, +0x8f420300, 0x24420001, 0xaf420300, 0x8f420300, +0x8f42002c, 0xa34005c1, 0x10000027, 0xaf420038, +0x8f440170, 0x8f450174, 0x8f43002c, 0x8f48000c, +0x8f860120, 0x24020080, 0xafa20010, 0xafa30014, 0xafa80018, 0x8f42010c, 0x40f809, 0x24c6001c, 0x14400011, 0x24020001, 0x3c010001, 0x370821, -0xa02240f2, 0x8f820124, 0xafa20010, 0x8f820128, -0x3c040001, 0x248461dc, 0xafa20014, 0x8f460044, -0x8f870120, 0x3c050009, 0xc002b37, 0x34a51300, -0x1000000f, 0x0, 0x8f420304, 0x24420001, -0xaf420304, 0x8f420304, 0x8f420044, 0xaf42007c, -0x3c010001, 0x370821, 0xa02040f2, 0x10000004, -0xaf400078, 0x3c010001, 0x370821, 0xa02040f2, +0xa02240f1, 0x8f820124, 0xafa20010, 0x8f820128, +0x3c040001, 0x24847684, 0xafa20014, 0x8f46002c, +0x8f870120, 0x3c050009, 0xc002d3b, 0x34a51100, +0x10000037, 0x0, 0x8f420300, 0x8f43002c, +0x24420001, 0xaf420300, 0x8f420300, 0x24020001, +0xa34205c1, 0xaf430038, 0x3c010001, 0x370821, +0xa02040f1, 0x3c010001, 0x370821, 0xa02040f0, +0x10000027, 0xaf400034, 0x934205c1, 0x1040001e, +0x0, 0xa34005c1, 0x8f820040, 0x30420001, +0x14400008, 0x2021, 0x8c030104, 0x24020001, +0x50620005, 0x24040001, 0x8c020264, 0x10400003, +0x801021, 0x24040001, 0x801021, 0x10400007, +0x0, 0x8f42030c, 0x24420001, 0xaf42030c, +0x8f42030c, 0x10000008, 0x0, 0x8f820044, +0x34420004, 0xaf820044, 0x8f420308, 0x24420001, +0xaf420308, 0x8f420308, 0x3c010001, 0x370821, +0xa02040f0, 0x3c010001, 0x370821, 0xa02040f1, 0x8f420000, 0x10400007, 0x0, 0xaf80004c, 0x8f82004c, 0x1040fffd, 0x0, 0x10000005, 0x0, 0xaf800048, 0x8f820048, 0x1040fffd, -0x0, 0x8f820060, 0x3c03feff, 0x3463ffff, -0x431024, 0xaf820060, 0x8f420000, 0x10400003, -0x0, 0x10000002, 0xaf80004c, 0xaf800048, +0x0, 0x8f820060, 0x3c03ff7f, 0x3463ffff, +0x431024, 0xaf820060, 0x8f420000, 0x10400004, +0x0, 0xaf80004c, 0x10000002, 0x0, +0xaf800048, 0x8fbf0020, 0x3e00008, 0x27bd0028, +0x3e00008, 0x0, 0x27bdffd8, 0xafbf0020, +0x8f430044, 0x8f42007c, 0x10620029, 0x24070008, +0x8f440168, 0x8f45016c, 0x8f48000c, 0x8f860120, +0x24020040, 0xafa20010, 0xafa30014, 0xafa80018, +0x8f42010c, 0x40f809, 0x24c6001c, 0x14400011, +0x24020001, 0x3c010001, 0x370821, 0xa02240f2, +0x8f820124, 0xafa20010, 0x8f820128, 0x3c040001, +0x2484768c, 0xafa20014, 0x8f460044, 0x8f870120, +0x3c050009, 0xc002d3b, 0x34a51300, 0x1000000f, +0x0, 0x8f420304, 0x24420001, 0xaf420304, +0x8f420304, 0x8f420044, 0xaf42007c, 0x3c010001, +0x370821, 0xa02040f2, 0x10000004, 0xaf400078, +0x3c010001, 0x370821, 0xa02040f2, 0x8f420000, +0x10400007, 0x0, 0xaf80004c, 0x8f82004c, +0x1040fffd, 0x0, 0x10000005, 0x0, +0xaf800048, 0x8f820048, 0x1040fffd, 0x0, +0x8f820060, 0x3c03feff, 0x3463ffff, 0x431024, +0xaf820060, 0x8f420000, 0x10400004, 0x0, +0xaf80004c, 0x10000002, 0x0, 0xaf800048, 0x8fbf0020, 0x3e00008, 0x27bd0028, 0x3e00008, -0x0, 0x3c020001, 0x8c426e68, 0x27bdffa8, +0x0, 0x3c020002, 0x8c4284dc, 0x27bdffa8, 0xafbf0050, 0xafbe004c, 0xafb50048, 0xafb30044, -0xafb20040, 0xafb1003c, 0xafb00038, 0x104000d5, -0x8f900044, 0x8f4200d0, 0x24430001, 0x2842000b, -0x144000e4, 0xaf4300d0, 0x8f420004, 0x30420002, -0x1440009c, 0xaf4000d0, 0x8f420004, 0x3c030001, -0x8c636e58, 0x34420002, 0xaf420004, 0x24020001, -0x14620003, 0x3c020600, 0x10000002, 0x34423000, -0x34421000, 0xafa20020, 0x8f4a0018, 0xafaa0034, -0x27aa0020, 0xafaa002c, 0x8faa0034, 0x240200ff, -0x11420002, 0x1821, 0x25430001, 0x8c020228, -0x609821, 0x1662000e, 0x3c050009, 0x8f42033c, -0x24420001, 0xaf42033c, 0x8f42033c, 0x8c020228, -0x8fa70034, 0x3c040001, 0x248461ac, 0xafa00014, -0xafa20010, 0x8fa60020, 0x10000070, 0x34a50500, -0x8faa0034, 0xa38c0, 0xf71021, 0x8fa30020, -0x8fa40024, 0xac4304c0, 0xac4404c4, 0x8f830054, -0x8f820054, 0x247103e8, 0x2221023, 0x2c4203e9, -0x1040001b, 0xa821, 0xe09021, 0x265e04c0, -0x8f440178, 0x8f45017c, 0x2401821, 0x240a0004, -0xafaa0010, 0xafb30014, 0x8f48000c, 0x1021, -0x2fe3021, 0xafa80018, 0x8f48010c, 0x24070008, -0xa32821, 0xa3482b, 0x822021, 0x100f809, -0x892021, 0x54400006, 0x24150001, 0x8f820054, -0x2221023, 0x2c4203e9, 0x1440ffe9, 0x0, -0x32a200ff, 0x54400018, 0xaf530018, 0x8f420378, -0x24420001, 0xaf420378, 0x8f420378, 0x8f820120, -0x8faa002c, 0x8fa70034, 0xafa20010, 0x8f820124, -0x3c040001, 0x248461b8, 0xafa20014, 0x8d460000, -0x3c050009, 0x10000035, 0x34a50600, 0x8f420308, -0x24150001, 0x24420001, 0xaf420308, 0x8f420308, -0x1000001e, 0x32a200ff, 0x8f830054, 0x8f820054, -0x247103e8, 0x2221023, 0x2c4203e9, 0x10400016, -0xa821, 0x3c1e0020, 0x24120010, 0x8f42000c, -0x8f440160, 0x8f450164, 0x8f860120, 0xafb20010, -0xafb30014, 0x5e1025, 0xafa20018, 0x8f42010c, -0x24070008, 0x40f809, 0x24c6001c, 0x1440ffe3, -0x0, 0x8f820054, 0x2221023, 0x2c4203e9, -0x1440ffee, 0x0, 0x32a200ff, 0x14400011, -0x3c050009, 0x8f420378, 0x24420001, 0xaf420378, -0x8f420378, 0x8f820120, 0x8faa002c, 0x8fa70034, -0xafa20010, 0x8f820124, 0x3c040001, 0x248461c0, -0xafa20014, 0x8d460000, 0x34a50700, 0xc002b37, -0x0, 0x8f4202ec, 0x24420001, 0xaf4202ec, -0x8f4202ec, 0x8f420004, 0x30420001, 0x50400029, -0x36100040, 0x3c020400, 0x2c21024, 0x10400013, -0x2404ffdf, 0x8f420250, 0x8f430254, 0x8f4401b4, -0x14640006, 0x36100040, 0x8f420270, 0x8f430274, -0x8f4401b8, 0x10640007, 0x2402ffdf, 0x8f420250, -0x8f430254, 0x8f440270, 0x8f450274, 0x10000012, -0x3a100020, 0x1000002b, 0x2028024, 0x8f420250, -0x8f430254, 0x8f4501b4, 0x14650006, 0x2048024, -0x8f420270, 0x8f430274, 0x8f4401b8, 0x50640021, -0x36100040, 0x8f420250, 0x8f430254, 0x8f440270, -0x8f450274, 0x3a100040, 0xaf4301b4, 0x10000019, -0xaf4501b8, 0x8f4200d4, 0x24430001, 0x10000011, -0x28420033, 0x8f420004, 0x30420001, 0x10400009, -0x3c020400, 0x2c21024, 0x10400004, 0x2402ffdf, -0x2028024, 0x1000000b, 0x36100040, 0x10000009, -0x36100060, 0x8f4200d4, 0x36100040, 0x24430001, -0x284201f5, 0x14400003, 0xaf4300d4, 0xaf4000d4, -0x3a100020, 0xaf900044, 0x2402ff7f, 0x282a024, -0x8fbf0050, 0x8fbe004c, 0x8fb50048, 0x8fb30044, -0x8fb20040, 0x8fb1003c, 0x8fb00038, 0x3e00008, -0x27bd0058, 0x3e00008, 0x0, 0x3c020001, -0x8c426e68, 0x27bdffb0, 0xafbf0048, 0xafbe0044, -0xafb50040, 0xafb3003c, 0xafb20038, 0xafb10034, -0x104000c7, 0xafb00030, 0x8f4200d0, 0x24430001, -0x2842000b, 0x144000da, 0xaf4300d0, 0x8f420004, -0x30420002, 0x14400097, 0xaf4000d0, 0x8f420004, -0x3c030001, 0x8c636e58, 0x34420002, 0xaf420004, +0xafb20040, 0xafb1003c, 0xafb00038, 0x8f900044, +0x104000d5, 0x0, 0x8f4200d0, 0x24430001, +0x2842000b, 0x144000e4, 0xaf4300d0, 0x8f420004, +0x30420002, 0x1440009c, 0xaf4000d0, 0x8f420004, +0x3c030002, 0x8c6384cc, 0x34420002, 0xaf420004, 0x24020001, 0x14620003, 0x3c020600, 0x10000002, -0x34423000, 0x34421000, 0xafa20020, 0x1821, -0x8f5e0018, 0x27aa0020, 0x240200ff, 0x13c20002, -0xafaa002c, 0x27c30001, 0x8c020228, 0x609021, -0x1642000e, 0x1e38c0, 0x8f42033c, 0x24420001, -0xaf42033c, 0x8f42033c, 0x8c020228, 0x3c040001, -0x248461ac, 0x3c050009, 0xafa00014, 0xafa20010, -0x8fa60020, 0x1000006d, 0x34a50500, 0xf71021, +0x34423000, 0x34421000, 0xafa20020, 0x8f4a0018, +0xafaa0034, 0x27aa0020, 0xafaa002c, 0x8faa0034, +0x240200ff, 0x11420002, 0x1821, 0x25430001, +0x8c020228, 0x609821, 0x1662000e, 0x3c050009, +0x8f42033c, 0x24420001, 0xaf42033c, 0x8f42033c, +0x8c020228, 0x8fa70034, 0x3c040001, 0x2484765c, +0xafa00014, 0xafa20010, 0x8fa60020, 0x10000070, +0x34a50500, 0x8faa0034, 0xa38c0, 0xf71021, 0x8fa30020, 0x8fa40024, 0xac4304c0, 0xac4404c4, -0x8f830054, 0x8f820054, 0x247003e8, 0x2021023, -0x2c4203e9, 0x1040001b, 0x9821, 0xe08821, -0x263504c0, 0x8f440178, 0x8f45017c, 0x2201821, -0x240a0004, 0xafaa0010, 0xafb20014, 0x8f48000c, -0x1021, 0x2f53021, 0xafa80018, 0x8f48010c, +0x8f830054, 0x8f820054, 0x247103e8, 0x2221023, +0x2c4203e9, 0x1040001b, 0xa821, 0xe09021, +0x265e04c0, 0x8f440178, 0x8f45017c, 0x2401821, +0x240a0004, 0xafaa0010, 0xafb30014, 0x8f48000c, +0x1021, 0x2fe3021, 0xafa80018, 0x8f48010c, 0x24070008, 0xa32821, 0xa3482b, 0x822021, -0x100f809, 0x892021, 0x54400006, 0x24130001, -0x8f820054, 0x2021023, 0x2c4203e9, 0x1440ffe9, -0x0, 0x326200ff, 0x54400017, 0xaf520018, +0x100f809, 0x892021, 0x54400006, 0x24150001, +0x8f820054, 0x2221023, 0x2c4203e9, 0x1440ffe9, +0x0, 0x32a200ff, 0x54400018, 0xaf530018, 0x8f420378, 0x24420001, 0xaf420378, 0x8f420378, -0x8f820120, 0x8faa002c, 0xafa20010, 0x8f820124, -0x3c040001, 0x248461b8, 0x3c050009, 0xafa20014, -0x8d460000, 0x10000035, 0x34a50600, 0x8f420308, -0x24130001, 0x24420001, 0xaf420308, 0x8f420308, -0x1000001e, 0x326200ff, 0x8f830054, 0x8f820054, -0x247003e8, 0x2021023, 0x2c4203e9, 0x10400016, -0x9821, 0x3c150020, 0x24110010, 0x8f42000c, -0x8f440160, 0x8f450164, 0x8f860120, 0xafb10010, -0xafb20014, 0x551025, 0xafa20018, 0x8f42010c, -0x24070008, 0x40f809, 0x24c6001c, 0x1440ffe3, -0x0, 0x8f820054, 0x2021023, 0x2c4203e9, -0x1440ffee, 0x0, 0x326200ff, 0x14400011, -0x0, 0x8f420378, 0x24420001, 0xaf420378, +0x8f820120, 0x8faa002c, 0x8fa70034, 0xafa20010, +0x8f820124, 0x3c040001, 0x24847668, 0xafa20014, +0x8d460000, 0x3c050009, 0x10000035, 0x34a50600, +0x8f420308, 0x24150001, 0x24420001, 0xaf420308, +0x8f420308, 0x1000001e, 0x32a200ff, 0x8f830054, +0x8f820054, 0x247103e8, 0x2221023, 0x2c4203e9, +0x10400016, 0xa821, 0x3c1e0020, 0x24120010, +0x8f42000c, 0x8f440160, 0x8f450164, 0x8f860120, +0xafb20010, 0xafb30014, 0x5e1025, 0xafa20018, +0x8f42010c, 0x24070008, 0x40f809, 0x24c6001c, +0x1440ffe3, 0x0, 0x8f820054, 0x2221023, +0x2c4203e9, 0x1440ffee, 0x0, 0x32a200ff, +0x14400011, 0x3c050009, 0x8f420378, 0x24420001, +0xaf420378, 0x8f420378, 0x8f820120, 0x8faa002c, +0x8fa70034, 0xafa20010, 0x8f820124, 0x3c040001, +0x24847670, 0xafa20014, 0x8d460000, 0x34a50700, +0xc002d3b, 0x0, 0x8f4202ec, 0x24420001, +0xaf4202ec, 0x8f4202ec, 0x8f420004, 0x30420001, +0x50400029, 0x36100040, 0x3c020400, 0x2c21024, +0x10400013, 0x2404ffdf, 0x8f420250, 0x8f430254, +0x8f4401b4, 0x14640006, 0x36100040, 0x8f420270, +0x8f430274, 0x8f4401b8, 0x10640007, 0x2402ffdf, +0x8f420250, 0x8f430254, 0x8f440270, 0x8f450274, +0x10000012, 0x3a100020, 0x1000002b, 0x2028024, +0x8f420250, 0x8f430254, 0x8f4501b4, 0x14650006, +0x2048024, 0x8f420270, 0x8f430274, 0x8f4401b8, +0x50640021, 0x36100040, 0x8f420250, 0x8f430254, +0x8f440270, 0x8f450274, 0x3a100040, 0xaf4301b4, +0x10000019, 0xaf4501b8, 0x8f4200d4, 0x24430001, +0x10000011, 0x28420033, 0x8f420004, 0x30420001, +0x10400009, 0x3c020400, 0x2c21024, 0x10400004, +0x2402ffdf, 0x2028024, 0x1000000b, 0x36100040, +0x10000009, 0x36100060, 0x8f4200d4, 0x36100040, +0x24430001, 0x284201f5, 0x14400003, 0xaf4300d4, +0xaf4000d4, 0x3a100020, 0xaf900044, 0x2402ff7f, +0x282a024, 0x8fbf0050, 0x8fbe004c, 0x8fb50048, +0x8fb30044, 0x8fb20040, 0x8fb1003c, 0x8fb00038, +0x3e00008, 0x27bd0058, 0x3e00008, 0x0, +0x3c020002, 0x8c4284dc, 0x27bdffb0, 0xafbf0048, +0xafbe0044, 0xafb50040, 0xafb3003c, 0xafb20038, +0xafb10034, 0x104000c9, 0xafb00030, 0x8f4200d0, +0x24430001, 0x2842000b, 0x144000dd, 0xaf4300d0, +0x8f420004, 0x30420002, 0x14400097, 0xaf4000d0, +0x8f420004, 0x3c030002, 0x8c6384cc, 0x34420002, +0xaf420004, 0x24020001, 0x14620003, 0x3c020600, +0x10000002, 0x34423000, 0x34421000, 0xafa20020, +0x1821, 0x8f5e0018, 0x27aa0020, 0x240200ff, +0x13c20002, 0xafaa002c, 0x27c30001, 0x8c020228, +0x609021, 0x1642000e, 0x1e38c0, 0x8f42033c, +0x24420001, 0xaf42033c, 0x8f42033c, 0x8c020228, +0x3c040001, 0x2484765c, 0x3c050009, 0xafa00014, +0xafa20010, 0x8fa60020, 0x1000006d, 0x34a50500, +0xf71021, 0x8fa30020, 0x8fa40024, 0xac4304c0, +0xac4404c4, 0x8f830054, 0x8f820054, 0x247003e8, +0x2021023, 0x2c4203e9, 0x1040001b, 0x9821, +0xe08821, 0x263504c0, 0x8f440178, 0x8f45017c, +0x2201821, 0x240a0004, 0xafaa0010, 0xafb20014, +0x8f48000c, 0x1021, 0x2f53021, 0xafa80018, +0x8f48010c, 0x24070008, 0xa32821, 0xa3482b, +0x822021, 0x100f809, 0x892021, 0x54400006, +0x24130001, 0x8f820054, 0x2021023, 0x2c4203e9, +0x1440ffe9, 0x0, 0x326200ff, 0x54400017, +0xaf520018, 0x8f420378, 0x24420001, 0xaf420378, 0x8f420378, 0x8f820120, 0x8faa002c, 0xafa20010, -0x8f820124, 0x3c040001, 0x248461c0, 0x3c050009, -0xafa20014, 0x8d460000, 0x34a50700, 0xc002b37, -0x3c03821, 0x8f4202ec, 0x24420001, 0xaf4202ec, -0x8f4202ec, 0x8f420004, 0x30420001, 0x10400018, -0x24040001, 0x8f420250, 0x8f430254, 0x8f4501b4, -0x3c010001, 0x14650006, 0xa0246db1, 0x8f420270, -0x8f430274, 0x8f4401b8, 0x10640021, 0x0, -0x8f420250, 0x8f430254, 0x3c040001, 0x90846db0, -0x8f460270, 0x8f470274, 0x38840001, 0xaf4301b4, -0xaf4701b8, 0x3c010001, 0x10000025, 0xa0246db0, -0x8f4200d4, 0x3c010001, 0xa0206db0, 0x24430001, -0x28420033, 0x1440001e, 0xaf4300d4, 0x3c020001, -0x90426db1, 0xaf4000d4, 0x10000017, 0x38420001, -0x8f420004, 0x30420001, 0x10400008, 0x0, -0xc00568a, 0x2021, 0x3c010001, 0xa0206db1, -0x3c010001, 0x1000000e, 0xa0206db0, 0x8f4200d4, -0x3c010001, 0xa0206db0, 0x24430001, 0x284201f5, -0x14400007, 0xaf4300d4, 0x3c020001, 0x90426db1, -0xaf4000d4, 0x421026, 0x3c010001, 0xa0226db1, -0x3c030001, 0x8c636e58, 0x24020002, 0x1462000c, -0x3c030002, 0x3c030001, 0x90636db1, 0x24020001, -0x5462001f, 0x2021, 0x3c020001, 0x90426db0, +0x8f820124, 0x3c040001, 0x24847668, 0x3c050009, +0xafa20014, 0x8d460000, 0x10000035, 0x34a50600, +0x8f420308, 0x24130001, 0x24420001, 0xaf420308, +0x8f420308, 0x1000001e, 0x326200ff, 0x8f830054, +0x8f820054, 0x247003e8, 0x2021023, 0x2c4203e9, +0x10400016, 0x9821, 0x3c150020, 0x24110010, +0x8f42000c, 0x8f440160, 0x8f450164, 0x8f860120, +0xafb10010, 0xafb20014, 0x551025, 0xafa20018, +0x8f42010c, 0x24070008, 0x40f809, 0x24c6001c, +0x1440ffe3, 0x0, 0x8f820054, 0x2021023, +0x2c4203e9, 0x1440ffee, 0x0, 0x326200ff, +0x14400011, 0x0, 0x8f420378, 0x24420001, +0xaf420378, 0x8f420378, 0x8f820120, 0x8faa002c, +0xafa20010, 0x8f820124, 0x3c040001, 0x24847670, +0x3c050009, 0xafa20014, 0x8d460000, 0x34a50700, +0xc002d3b, 0x3c03821, 0x8f4202ec, 0x24420001, +0xaf4202ec, 0x8f4202ec, 0x8f420004, 0x30420001, +0x1040001a, 0x24040001, 0x8f420250, 0x8f430254, +0x8f4501b4, 0x3c010002, 0xa0248449, 0x14650006, +0x0, 0x8f420270, 0x8f430274, 0x8f4401b8, +0x10640022, 0x0, 0x8f420250, 0x8f430254, +0x3c040002, 0x90848448, 0x8f460270, 0x8f470274, +0x38840001, 0xaf4301b4, 0xaf4701b8, 0x3c010002, +0xa0248448, 0x10000026, 0x0, 0x8f4200d4, +0x3c010002, 0xa0208448, 0x24430001, 0x28420033, +0x1440001f, 0xaf4300d4, 0x3c020002, 0x90428449, +0xaf4000d4, 0x10000018, 0x38420001, 0x8f420004, +0x30420001, 0x10400009, 0x0, 0xc005c2d, +0x2021, 0x3c010002, 0xa0208449, 0x3c010002, +0xa0208448, 0x1000000e, 0x0, 0x8f4200d4, +0x3c010002, 0xa0208448, 0x24430001, 0x284201f5, +0x14400007, 0xaf4300d4, 0x3c020002, 0x90428449, +0xaf4000d4, 0x421026, 0x3c010002, 0xa0228449, +0x3c030002, 0x8c6384cc, 0x24020002, 0x1462000c, +0x3c030002, 0x3c030002, 0x90638449, 0x24020001, +0x5462001f, 0x2021, 0x3c020002, 0x90428448, 0x1443001b, 0x24040005, 0x10000019, 0x24040006, -0x3c020002, 0x8c4290b4, 0x431024, 0x1040000b, -0x24020001, 0x3c030001, 0x90636db1, 0x54620010, -0x2021, 0x3c020001, 0x90426db0, 0x1443000c, -0x24040003, 0x1000000a, 0x24040004, 0x3c030001, -0x90636db1, 0x14620006, 0x2021, 0x3c020001, -0x90426db0, 0x24040001, 0x50440001, 0x24040002, -0xc00568a, 0x0, 0x2402ff7f, 0x282a024, +0x3c020002, 0x8c42a714, 0x431024, 0x1040000b, +0x24020001, 0x3c030002, 0x90638449, 0x54620010, +0x2021, 0x3c020002, 0x90428448, 0x1443000c, +0x24040003, 0x1000000a, 0x24040004, 0x3c030002, +0x90638449, 0x14620006, 0x2021, 0x3c020002, +0x90428448, 0x24040001, 0x50440001, 0x24040002, +0xc005c2d, 0x0, 0x2402ff7f, 0x282a024, 0x8fbf0048, 0x8fbe0044, 0x8fb50040, 0x8fb3003c, 0x8fb20038, 0x8fb10034, 0x8fb00030, 0x3e00008, -0x27bd0050, 0x3e00008, 0x0, 0x3c020001, -0x8c426e68, 0x27bdffb0, 0xafbf0048, 0xafbe0044, +0x27bd0050, 0x3e00008, 0x0, 0x3c020002, +0x8c4284dc, 0x27bdffb0, 0xafbf0048, 0xafbe0044, 0xafb50040, 0xafb3003c, 0xafb20038, 0xafb10034, -0x104000de, 0xafb00030, 0x8f4200d0, 0x3c040001, -0x8c846e58, 0x24430001, 0x2842000b, 0xaf4400e8, +0x104000de, 0xafb00030, 0x8f4200d0, 0x3c040002, +0x8c8484cc, 0x24430001, 0x2842000b, 0xaf4400e8, 0x144000fe, 0xaf4300d0, 0x8f420004, 0x30420002, 0x14400095, 0xaf4000d0, 0x8f420004, 0x34420002, 0xaf420004, 0x24020001, 0x14820003, 0x3c020600, @@ -834,7 +895,7 @@ 0x13c20002, 0xafaa002c, 0x27c30001, 0x8c020228, 0x609021, 0x1642000e, 0x1e38c0, 0x8f42033c, 0x24420001, 0xaf42033c, 0x8f42033c, 0x8c020228, -0x3c040001, 0x248461ac, 0x3c050009, 0xafa00014, +0x3c040001, 0x2484765c, 0x3c050009, 0xafa00014, 0xafa20010, 0x8fa60020, 0x1000006d, 0x34a50500, 0xf71021, 0x8fa30020, 0x8fa40024, 0xac4304c0, 0xac4404c4, 0x8f830054, 0x8f820054, 0x247003e8, @@ -848,7 +909,7 @@ 0x1440ffe9, 0x0, 0x326200ff, 0x54400017, 0xaf520018, 0x8f420378, 0x24420001, 0xaf420378, 0x8f420378, 0x8f820120, 0x8faa002c, 0xafa20010, -0x8f820124, 0x3c040001, 0x248461b8, 0x3c050009, +0x8f820124, 0x3c040001, 0x24847668, 0x3c050009, 0xafa20014, 0x8d460000, 0x10000035, 0x34a50600, 0x8f420308, 0x24130001, 0x24420001, 0xaf420308, 0x8f420308, 0x1000001e, 0x326200ff, 0x8f830054, @@ -861,9 +922,9 @@ 0x2c4203e9, 0x1440ffee, 0x0, 0x326200ff, 0x14400011, 0x0, 0x8f420378, 0x24420001, 0xaf420378, 0x8f420378, 0x8f820120, 0x8faa002c, -0xafa20010, 0x8f820124, 0x3c040001, 0x248461c0, +0xafa20010, 0x8f820124, 0x3c040001, 0x24847670, 0x3c050009, 0xafa20014, 0x8d460000, 0x34a50700, -0xc002b37, 0x3c03821, 0x8f4202ec, 0x24420001, +0xc002d3b, 0x3c03821, 0x8f4202ec, 0x24420001, 0xaf4202ec, 0x8f4202ec, 0x8f420004, 0x30420001, 0x10400033, 0x3c020400, 0x2c21024, 0x10400017, 0x0, 0x934205c0, 0x8f440250, 0x8f450254, @@ -893,7 +954,7 @@ 0x8f4300e8, 0x3042007f, 0xa34205c0, 0x24020001, 0x14620005, 0x0, 0x934405c0, 0x42102, 0x10000003, 0x348400f0, 0x934405c0, 0x3484000f, -0xc005670, 0x0, 0x2402ff7f, 0x282a024, +0xc005c13, 0x0, 0x2402ff7f, 0x282a024, 0x8fbf0048, 0x8fbe0044, 0x8fb50040, 0x8fb3003c, 0x8fb20038, 0x8fb10034, 0x8fb00030, 0x3e00008, 0x27bd0050, 0x3e00008, 0x0, 0x27bdffb0, @@ -940,13 +1001,13 @@ 0xa32825, 0x24020008, 0xaee400c8, 0xaee500cc, 0xafa20010, 0xafa00014, 0x8f42000c, 0x8c040208, 0x8c05020c, 0xafa20018, 0x8f42010c, 0x26e60028, -0x40f809, 0x24070400, 0x104000f0, 0x3c020400, +0x40f809, 0x24070400, 0x104000f1, 0x3c020400, 0xafa20020, 0x934205c6, 0x10400089, 0x1821, 0x8f5e0018, 0x27aa0020, 0x240200ff, 0x13c20002, 0xafaa002c, 0x27c30001, 0x8c020228, 0x609021, 0x1642000e, 0x1e38c0, 0x8f42033c, 0x24420001, 0xaf42033c, 0x8f42033c, 0x8c020228, 0x3c040001, -0x248461ac, 0x3c050009, 0xafa00014, 0xafa20010, +0x2484765c, 0x3c050009, 0xafa00014, 0xafa20010, 0x8fa60020, 0x1000006b, 0x34a50500, 0xf71021, 0x8fa30020, 0x8fa40024, 0xac4304c0, 0xac4404c4, 0x8f830054, 0x8f820054, 0x247003e8, 0x2021023, @@ -960,7 +1021,7 @@ 0x0, 0x326200ff, 0x54400017, 0xaf520018, 0x8f420378, 0x24420001, 0xaf420378, 0x8f420378, 0x8f820120, 0x8faa002c, 0xafa20010, 0x8f820124, -0x3c040001, 0x248461b8, 0x3c050009, 0xafa20014, +0x3c040001, 0x24847668, 0x3c050009, 0xafa20014, 0x8d460000, 0x10000033, 0x34a50600, 0x8f420308, 0x24130001, 0x24420001, 0xaf420308, 0x8f420308, 0x1000001c, 0x326200ff, 0x8f830054, 0x8f820054, @@ -973,13 +1034,13 @@ 0x326200ff, 0x54400012, 0x24020001, 0x8f420378, 0x24420001, 0xaf420378, 0x8f420378, 0x8f820120, 0x8faa002c, 0xafa20010, 0x8f820124, 0x3c040001, -0x248461c0, 0x3c050009, 0xafa20014, 0x8d460000, -0x34a50700, 0xc002b37, 0x3c03821, 0x1021, -0x1440005b, 0x24020001, 0x10000065, 0x0, +0x24847670, 0x3c050009, 0xafa20014, 0x8d460000, +0x34a50700, 0xc002d3b, 0x3c03821, 0x1021, +0x1440005b, 0x24020001, 0x10000066, 0x0, 0x8f510018, 0x240200ff, 0x12220002, 0x8021, 0x26300001, 0x8c020228, 0x1602000e, 0x1130c0, 0x8f42033c, 0x24420001, 0xaf42033c, 0x8f42033c, -0x8c020228, 0x3c040001, 0x24846194, 0x3c050009, +0x8c020228, 0x3c040001, 0x24847644, 0x3c050009, 0xafa00014, 0xafa20010, 0x8fa60020, 0x1000003f, 0x34a50100, 0xd71021, 0x8fa30020, 0x8fa40024, 0xac4304c0, 0xac4404c4, 0xc01821, 0x8f440178, @@ -988,86 +1049,87 @@ 0xafa80018, 0x8f48010c, 0x24070008, 0xa32821, 0xa3482b, 0x822021, 0x100f809, 0x892021, 0x1440000b, 0x24070008, 0x8f820120, 0xafa20010, -0x8f820124, 0x3c040001, 0x2484619c, 0x3c050009, +0x8f820124, 0x3c040001, 0x2484764c, 0x3c050009, 0xafa20014, 0x8fa60020, 0x1000001c, 0x34a50200, 0x8f440160, 0x8f450164, 0x8f43000c, 0xaf500018, 0x8f860120, 0x24020010, 0xafa20010, 0xafb00014, 0xafa30018, 0x8f42010c, 0x40f809, 0x24c6001c, 0x54400011, 0x24020001, 0x8f420340, 0x24420001, 0xaf420340, 0x8f420340, 0x8f820120, 0xafa20010, -0x8f820124, 0x3c040001, 0x248461a4, 0x3c050009, -0xafa20014, 0x8fa60020, 0x34a50300, 0xc002b37, -0x2203821, 0x1021, 0x1040000d, 0x24020001, +0x8f820124, 0x3c040001, 0x24847654, 0x3c050009, +0xafa20014, 0x8fa60020, 0x34a50300, 0xc002d3b, +0x2203821, 0x1021, 0x1040000e, 0x24020001, 0x8f4202e8, 0xa34005c6, 0xaf4001b0, 0x24420001, 0xaf4202e8, 0x8f4202e8, 0x8ee20150, 0x24420001, -0xaee20150, 0x10000003, 0x8ee20150, 0x24020001, -0xa34205c6, 0x8fbf0048, 0x8fbe0044, 0x8fb50040, -0x8fb3003c, 0x8fb20038, 0x8fb10034, 0x8fb00030, -0x3e00008, 0x27bd0050, 0x27bdffd8, 0xafbf0020, -0x8f8200b0, 0x30420004, 0x10400068, 0x0, +0xaee20150, 0x8ee20150, 0x10000003, 0x0, +0x24020001, 0xa34205c6, 0x8fbf0048, 0x8fbe0044, +0x8fb50040, 0x8fb3003c, 0x8fb20038, 0x8fb10034, +0x8fb00030, 0x3e00008, 0x27bd0050, 0x27bdffd8, +0xafbf0020, 0x8f8200b0, 0x30420004, 0x10400069, +0x0, 0x8f430128, 0x8f820104, 0x14620005, +0x0, 0x8f430130, 0x8f8200b4, 0x10620006, +0x0, 0x8f820104, 0xaf420128, 0x8f8200b4, +0x1000005c, 0xaf420130, 0x8f8200b0, 0x3c030080, +0x431024, 0x1040000e, 0x0, 0x8f82011c, +0x34420002, 0xaf82011c, 0x8f8200b0, 0x2403fffb, +0x431024, 0xaf8200b0, 0x8f82011c, 0x2403fffd, +0x431024, 0xaf82011c, 0x1000004a, 0x0, 0x8f430128, 0x8f820104, 0x14620005, 0x0, -0x8f430130, 0x8f8200b4, 0x10620006, 0x0, -0x8f820104, 0xaf420128, 0x8f8200b4, 0x1000005b, -0xaf420130, 0x8f8200b0, 0x3c030080, 0x431024, -0x1040000d, 0x0, 0x8f82011c, 0x34420002, -0xaf82011c, 0x8f8200b0, 0x2403fffb, 0x431024, -0xaf8200b0, 0x8f82011c, 0x2403fffd, 0x431024, -0x1000004a, 0xaf82011c, 0x8f430128, 0x8f820104, -0x14620005, 0x0, 0x8f430130, 0x8f8200b4, -0x10620010, 0x0, 0x8f820104, 0xaf420128, -0x8f8200b4, 0x8f430128, 0xaf420130, 0xafa30010, -0x8f420130, 0x3c040001, 0x248461e4, 0xafa20014, -0x8f86011c, 0x8f8700b0, 0x3c050005, 0x10000031, -0x34a50900, 0x8f420128, 0xafa20010, 0x8f420130, -0x3c040001, 0x248461f0, 0xafa20014, 0x8f86011c, -0x8f8700b0, 0x3c050005, 0xc002b37, 0x34a51000, -0x8f82011c, 0x34420002, 0xaf82011c, 0x8f830104, -0x8f8200b0, 0x34420001, 0xaf8200b0, 0x24020008, -0xaf830104, 0xafa20010, 0xafa00014, 0x8f42000c, -0x8c040208, 0x8c05020c, 0xafa20018, 0x8f42010c, -0x26e60028, 0x40f809, 0x24070400, 0x8f82011c, -0x2403fffd, 0x431024, 0xaf82011c, 0x8ee201dc, -0x24420001, 0xaee201dc, 0x8ee201dc, 0x8f420128, -0xafa20010, 0x8f420130, 0x3c040001, 0x248461fc, +0x8f430130, 0x8f8200b4, 0x10620010, 0x0, +0x8f820104, 0xaf420128, 0x8f8200b4, 0x8f430128, +0xaf420130, 0xafa30010, 0x8f420130, 0x3c040001, +0x248476ac, 0xafa20014, 0x8f86011c, 0x8f8700b0, +0x3c050005, 0x10000031, 0x34a50900, 0x8f420128, +0xafa20010, 0x8f420130, 0x3c040001, 0x248476b8, 0xafa20014, 0x8f86011c, 0x8f8700b0, 0x3c050005, -0x34a51100, 0xc002b37, 0x0, 0x8f8200a0, -0x30420004, 0x10400069, 0x0, 0x8f43012c, -0x8f820124, 0x14620005, 0x0, 0x8f430134, -0x8f8200a4, 0x10620006, 0x0, 0x8f820124, -0xaf42012c, 0x8f8200a4, 0x1000005c, 0xaf420134, -0x8f8200a0, 0x3c030080, 0x431024, 0x1040000d, -0x0, 0x8f82011c, 0x34420002, 0xaf82011c, -0x8f8200a0, 0x2403fffb, 0x431024, 0xaf8200a0, -0x8f82011c, 0x2403fffd, 0x431024, 0x1000004b, -0xaf82011c, 0x8f43012c, 0x8f820124, 0x14620005, -0x0, 0x8f430134, 0x8f8200a4, 0x10620010, +0xc002d3b, 0x34a51000, 0x8f82011c, 0x34420002, +0xaf82011c, 0x8f830104, 0x8f8200b0, 0x34420001, +0xaf8200b0, 0x24020008, 0xaf830104, 0xafa20010, +0xafa00014, 0x8f42000c, 0x8c040208, 0x8c05020c, +0xafa20018, 0x8f42010c, 0x26e60028, 0x40f809, +0x24070400, 0x8f82011c, 0x2403fffd, 0x431024, +0xaf82011c, 0x8ee201dc, 0x24420001, 0xaee201dc, +0x8ee201dc, 0x8f420128, 0xafa20010, 0x8f420130, +0x3c040001, 0x248476c4, 0xafa20014, 0x8f86011c, +0x8f8700b0, 0x3c050005, 0x34a51100, 0xc002d3b, +0x0, 0x8f8200a0, 0x30420004, 0x1040006a, +0x0, 0x8f43012c, 0x8f820124, 0x14620005, +0x0, 0x8f430134, 0x8f8200a4, 0x10620006, 0x0, 0x8f820124, 0xaf42012c, 0x8f8200a4, -0x8f43012c, 0xaf420134, 0xafa30010, 0x8f420134, -0x3c040001, 0x24846208, 0xafa20014, 0x8f86011c, -0x8f8700a0, 0x3c050005, 0x10000032, 0x34a51200, -0x8f42012c, 0xafa20010, 0x8f420134, 0x3c040001, -0x24846214, 0xafa20014, 0x8f86011c, 0x8f8700a0, -0x3c050005, 0xc002b37, 0x34a51300, 0x8f82011c, -0x34420002, 0xaf82011c, 0x8f830124, 0x8f8200a0, -0x34420001, 0xaf8200a0, 0x24020080, 0xaf830124, -0xafa20010, 0xafa00014, 0x8f420014, 0x8c040208, -0x8c05020c, 0xafa20018, 0x8f420108, 0x3c060001, -0x24c66f98, 0x40f809, 0x24070004, 0x8f82011c, -0x2403fffd, 0x431024, 0xaf82011c, 0x8ee201dc, -0x24420001, 0xaee201dc, 0x8ee201dc, 0x8f42012c, -0xafa20010, 0x8f420134, 0x3c040001, 0x24846220, +0x1000005d, 0xaf420134, 0x8f8200a0, 0x3c030080, +0x431024, 0x1040000e, 0x0, 0x8f82011c, +0x34420002, 0xaf82011c, 0x8f8200a0, 0x2403fffb, +0x431024, 0xaf8200a0, 0x8f82011c, 0x2403fffd, +0x431024, 0xaf82011c, 0x1000004b, 0x0, +0x8f43012c, 0x8f820124, 0x14620005, 0x0, +0x8f430134, 0x8f8200a4, 0x10620010, 0x0, +0x8f820124, 0xaf42012c, 0x8f8200a4, 0x8f43012c, +0xaf420134, 0xafa30010, 0x8f420134, 0x3c040001, +0x248476d0, 0xafa20014, 0x8f86011c, 0x8f8700a0, +0x3c050005, 0x10000032, 0x34a51200, 0x8f42012c, +0xafa20010, 0x8f420134, 0x3c040001, 0x248476dc, 0xafa20014, 0x8f86011c, 0x8f8700a0, 0x3c050005, -0x34a51400, 0xc002b37, 0x0, 0x8fbf0020, -0x3e00008, 0x27bd0028, 0x3c081000, 0x24070001, -0x3c060080, 0x3c050100, 0x8f820070, 0x481024, -0x1040fffd, 0x0, 0x8f820054, 0x24420005, -0xaf820078, 0x8c040234, 0x10800016, 0x1821, -0x3c020001, 0x571021, 0x8c4240e8, 0x24420005, -0x3c010001, 0x370821, 0xac2240e8, 0x3c020001, -0x571021, 0x8c4240e8, 0x44102b, 0x14400009, -0x0, 0x3c030080, 0x3c010001, 0x370821, -0xac2040e8, 0x3c010001, 0x370821, 0x1000000b, -0xa02740f0, 0x3c020001, 0x571021, 0x904240f0, +0xc002d3b, 0x34a51300, 0x8f82011c, 0x34420002, +0xaf82011c, 0x8f830124, 0x8f8200a0, 0x34420001, +0xaf8200a0, 0x24020080, 0xaf830124, 0xafa20010, +0xafa00014, 0x8f420014, 0x8c040208, 0x8c05020c, +0xafa20018, 0x8f420108, 0x3c060002, 0x24c685f8, +0x40f809, 0x24070004, 0x8f82011c, 0x2403fffd, +0x431024, 0xaf82011c, 0x8ee201dc, 0x24420001, +0xaee201dc, 0x8ee201dc, 0x8f42012c, 0xafa20010, +0x8f420134, 0x3c040001, 0x248476e8, 0xafa20014, +0x8f86011c, 0x8f8700a0, 0x3c050005, 0x34a51400, +0xc002d3b, 0x0, 0x8fbf0020, 0x3e00008, +0x27bd0028, 0x3c081000, 0x24070001, 0x3c060080, +0x3c050100, 0x8f820070, 0x481024, 0x1040fffd, +0x0, 0x8f820054, 0x24420005, 0xaf820078, +0x8c040234, 0x10800017, 0x1821, 0x3c020001, +0x571021, 0x8c4240e8, 0x24420005, 0x3c010001, +0x370821, 0xac2240e8, 0x3c020001, 0x571021, +0x8c4240e8, 0x44102b, 0x1440000a, 0x0, +0x3c030080, 0x3c010001, 0x370821, 0xac2040e8, +0x3c010001, 0x370821, 0xa02740f0, 0x1000000b, +0x0, 0x3c020001, 0x571021, 0x904240f0, 0x54400006, 0x661825, 0x3c020001, 0x571021, 0x904240f1, 0x54400001, 0x661825, 0x8c040230, 0x10800013, 0x0, 0x3c020001, 0x571021, @@ -1076,24 +1138,24 @@ 0x44102b, 0x14400006, 0x0, 0x3c010001, 0x370821, 0xac2040ec, 0x10000006, 0x651825, 0x3c020001, 0x571021, 0x904240f2, 0x54400001, -0x651825, 0x1060ffbc, 0x0, 0x8f420000, +0x651825, 0x1060ffbb, 0x0, 0x8f420000, 0x10400007, 0x0, 0xaf80004c, 0x8f82004c, 0x1040fffd, 0x0, 0x10000005, 0x0, 0xaf800048, 0x8f820048, 0x1040fffd, 0x0, 0x8f820060, 0x431025, 0xaf820060, 0x8f420000, -0x10400003, 0x0, 0x1000ffa7, 0xaf80004c, -0x1000ffa5, 0xaf800048, 0x3e00008, 0x0, -0x0, 0x0, 0x0, 0x27bdffe0, -0xafbf0018, 0x8f860064, 0x30c20004, 0x10400025, -0x24040004, 0x8c020114, 0xaf420020, 0xaf840064, -0x8f4202fc, 0x24420001, 0xaf4202fc, 0x8f4202fc, -0x8f820064, 0x30420004, 0x14400005, 0x0, -0x8c030114, 0x8f420020, 0x1462fff2, 0x0, -0x8f420000, 0x10400007, 0x8f43003c, 0xaf80004c, +0x10400004, 0x0, 0xaf80004c, 0x1000ffa5, +0x0, 0xaf800048, 0x1000ffa2, 0x0, +0x3e00008, 0x0, 0x27bdffe0, 0xafbf0018, +0x8f860064, 0x30c20004, 0x10400026, 0x24040004, +0x8c020114, 0xaf420020, 0xaf840064, 0x8f4202fc, +0x24420001, 0xaf4202fc, 0x8f4202fc, 0x8f820064, +0x30420004, 0x14400005, 0x0, 0x8c030114, +0x8f420020, 0x1462fff2, 0x0, 0x8f420000, +0x8f43003c, 0x10400007, 0x0, 0xaf80004c, 0x8f82004c, 0x1040fffd, 0x0, 0x10000005, 0x0, 0xaf800048, 0x8f820048, 0x1040fffd, 0x0, 0x8f820060, 0x431025, 0xaf820060, -0x8f420000, 0x10400073, 0x0, 0x1000006f, +0x8f420000, 0x10400074, 0x0, 0x1000006f, 0x0, 0x30c20008, 0x10400020, 0x24040008, 0x8c02011c, 0xaf420048, 0xaf840064, 0x8f4202a8, 0x24420001, 0xaf4202a8, 0x8f4202a8, 0x8f820064, @@ -1112,7 +1174,7 @@ 0x8f82004c, 0x1040fffd, 0x0, 0x10000005, 0x0, 0xaf800048, 0x8f820048, 0x1040fffd, 0x0, 0x8f820060, 0x1000ffb4, 0x34420800, -0x30c20010, 0x10400029, 0x24040010, 0x8c020124, +0x30c20010, 0x1040002b, 0x24040010, 0x8c020124, 0xaf420058, 0xaf840064, 0x8f4202d4, 0x24420001, 0xaf4202d4, 0x8f4202d4, 0x8f820064, 0x30420010, 0x14400005, 0x32c22000, 0x8c030124, 0x8f420058, @@ -1121,126 +1183,312 @@ 0x8f82004c, 0x1040fffd, 0x0, 0x10000005, 0x0, 0xaf800048, 0x8f820048, 0x1040fffd, 0x0, 0x8f820060, 0x34420100, 0xaf820060, -0x8f420000, 0x10400003, 0x0, 0x1000006c, -0xaf80004c, 0x1000006a, 0xaf800048, 0x30c20001, -0x10400004, 0x24020001, 0xaf820064, 0x10000064, -0x0, 0x30c20002, 0x1440000b, 0x3c050003, -0x3c040001, 0x248462e4, 0x34a50500, 0x3821, -0xafa00010, 0xc002b37, 0xafa00014, 0x2402ffc0, -0x10000057, 0xaf820064, 0x8c05022c, 0x8c02010c, -0x10a20048, 0x51080, 0x8c460300, 0x24a20001, -0x3045003f, 0x24020003, 0xac05022c, 0x61e02, -0x10620005, 0x24020010, 0x1062001d, 0x30c20fff, -0x10000039, 0x0, 0x8f4302a8, 0x8f440000, -0x30c20fff, 0xaf420048, 0x24630001, 0xaf4302a8, -0x10800007, 0x8f4202a8, 0xaf80004c, 0x8f82004c, +0x8f420000, 0x10400004, 0x0, 0xaf80004c, +0x10000072, 0x0, 0xaf800048, 0x1000006f, +0x0, 0x30c20001, 0x10400004, 0x24020001, +0xaf820064, 0x10000069, 0x0, 0x30c20002, +0x1440000c, 0x3c050003, 0x3c040001, 0x248477ac, +0x34a50500, 0x3821, 0xafa00010, 0xc002d3b, +0xafa00014, 0x2402ffc0, 0xaf820064, 0x1000005b, +0x0, 0x8c05022c, 0x8c02010c, 0x10a2004c, +0x51080, 0x8c460300, 0x24a20001, 0x3045003f, +0x24020003, 0xac05022c, 0x61e02, 0x10620005, +0x24020010, 0x1062001e, 0x30c20fff, 0x1000003d, +0x0, 0x8f4302a8, 0x8f440000, 0x30c20fff, +0xaf420048, 0x24630001, 0xaf4302a8, 0x8f4202a8, +0x10800007, 0x0, 0xaf80004c, 0x8f82004c, 0x1040fffd, 0x0, 0x10000005, 0x0, 0xaf800048, 0x8f820048, 0x1040fffd, 0x0, 0x8f820060, 0x34420200, 0xaf820060, 0x8f420000, -0x1040001f, 0x0, 0x1000001b, 0x0, +0x10400021, 0x0, 0x1000001c, 0x0, 0xaf420058, 0x32c22000, 0x50400001, 0x36d68000, 0x8f4202d4, 0x8f430000, 0x24420001, 0xaf4202d4, -0x10600007, 0x8f4202d4, 0xaf80004c, 0x8f82004c, -0x1040fffd, 0x0, 0x10000005, 0x0, -0xaf800048, 0x8f820048, 0x1040fffd, 0x0, -0x8f820060, 0x34420100, 0xaf820060, 0x8f420000, -0x10400003, 0x0, 0x10000006, 0xaf80004c, -0x10000004, 0xaf800048, 0xc002196, 0xc02021, -0x402821, 0x8c02010c, 0x14a20002, 0x24020002, -0xaf820064, 0x8f820064, 0x30420002, 0x14400004, -0x0, 0x8c02010c, 0x14a2ffac, 0x0, -0x8fbf0018, 0x3e00008, 0x27bd0020, 0x3e00008, -0x0, 0x27bdffa0, 0xafb00040, 0x808021, -0x101602, 0x2442ffff, 0x304300ff, 0x2c620013, -0xafbf0058, 0xafbe0054, 0xafb50050, 0xafb3004c, -0xafb20048, 0xafb10044, 0x104001f3, 0xafa50034, -0x31080, 0x3c010001, 0x220821, 0x8c226328, -0x400008, 0x0, 0x101302, 0x30440fff, -0x24020001, 0x10820005, 0x24020002, 0x1082000c, -0x2402fffe, 0x10000024, 0x3c050003, 0x8f430004, -0x3c020001, 0x8c426fc4, 0xaf440200, 0xaf440204, -0x3c040001, 0x8c846f40, 0x10000009, 0x34630001, -0x8f430004, 0xaf440200, 0xaf440204, 0x3c040001, -0x8c846f40, 0x621824, 0x3c020001, 0x2442ca18, -0x21100, 0x21182, 0xaf430004, 0x3c030800, -0x431025, 0xac820038, 0x8f840054, 0x41442, -0x41c82, 0x431021, 0x41cc2, 0x431023, -0x41d02, 0x431021, 0x41d42, 0x431023, -0x10000009, 0xaf420208, 0x3c040001, 0x248462f0, +0x8f4202d4, 0x10600007, 0x0, 0xaf80004c, +0x8f82004c, 0x1040fffd, 0x0, 0x10000005, +0x0, 0xaf800048, 0x8f820048, 0x1040fffd, +0x0, 0x8f820060, 0x34420100, 0xaf820060, +0x8f420000, 0x10400004, 0x0, 0xaf80004c, +0x10000007, 0x0, 0xaf800048, 0x10000004, +0x0, 0xc0022ad, 0xc02021, 0x402821, +0x8c02010c, 0x14a20002, 0x24020002, 0xaf820064, +0x8f820064, 0x30420002, 0x14400004, 0x0, +0x8c02010c, 0x14a2ffa8, 0x0, 0x8fbf0018, +0x3e00008, 0x27bd0020, 0x3e00008, 0x0, +0x27bdffa0, 0xafb00040, 0x808021, 0x101602, +0x2442ffff, 0x304300ff, 0x2c620013, 0xafbf0058, +0xafbe0054, 0xafb50050, 0xafb3004c, 0xafb20048, +0xafb10044, 0x104001fe, 0xafa50034, 0x31080, +0x3c010001, 0x220821, 0x8c2277f0, 0x400008, +0x0, 0x101302, 0x30440fff, 0x24020001, +0x10820005, 0x24020002, 0x1082000c, 0x2402fffe, +0x10000025, 0x3c050003, 0x8f430004, 0x3c020002, +0x8c428624, 0xaf440200, 0xaf440204, 0x3c040002, +0x8c8485a0, 0x10000009, 0x34630001, 0x8f430004, +0xaf440200, 0xaf440204, 0x3c040002, 0x8c8485a0, +0x621824, 0x3c020001, 0x2442d68c, 0x21100, +0x21182, 0xaf430004, 0x3c030800, 0x431025, +0xac820038, 0x8f840054, 0x41442, 0x41c82, +0x431021, 0x41cc2, 0x431023, 0x41d02, +0x431021, 0x41d42, 0x431023, 0xaf420208, +0x10000009, 0x0, 0x3c040001, 0x248477b8, 0x34a51000, 0x2003021, 0x3821, 0xafa00010, -0xc002b37, 0xafa00014, 0x8f4202a0, 0x24420001, -0xaf4202a0, 0x1000021f, 0x8f4202a0, 0x27b00028, -0x2002021, 0x24050210, 0xc002bbb, 0x24060008, -0xc002517, 0x2002021, 0x10000216, 0x0, -0x8faa0034, 0x27a40028, 0xa1880, 0x25420001, -0x3042003f, 0xafa20034, 0x8c650300, 0x8faa0034, -0x21080, 0x8c430300, 0x25420001, 0x3042003f, -0xafa20034, 0xac02022c, 0xafa50028, 0xc002517, -0xafa3002c, 0x10000203, 0x0, 0x27b00028, -0x2002021, 0x24050210, 0xc002bbb, 0x24060008, -0xc002656, 0x2002021, 0x100001fa, 0x0, -0x8faa0034, 0x27a40028, 0xa1880, 0x25420001, -0x3042003f, 0xafa20034, 0x8c650300, 0x8faa0034, -0x21080, 0x8c430300, 0x25420001, 0x3042003f, -0xafa20034, 0xac02022c, 0xafa50028, 0xc002656, -0xafa3002c, 0x100001e7, 0x0, 0x101302, -0x30430fff, 0x24020001, 0x10620005, 0x24020002, -0x1062001e, 0x3c020002, 0x10000033, 0x3c050003, -0x3c030002, 0x2c31024, 0x54400037, 0x2c3b025, -0x8f820228, 0x3c010001, 0x370821, 0xac2238d8, -0x8f82022c, 0x3c010001, 0x370821, 0xac2238dc, -0x8f820230, 0x3c010001, 0x370821, 0xac2238e0, -0x8f820234, 0x3c010001, 0x370821, 0xac2238e4, -0x2402ffff, 0xaf820228, 0xaf82022c, 0xaf820230, -0xaf820234, 0x10000020, 0x2c3b025, 0x2c21024, -0x10400012, 0x3c02fffd, 0x3c020001, 0x571021, -0x8c4238d8, 0xaf820228, 0x3c020001, 0x571021, -0x8c4238dc, 0xaf82022c, 0x3c020001, 0x571021, -0x8c4238e0, 0xaf820230, 0x3c020001, 0x571021, -0x8c4238e4, 0xaf820234, 0x3c02fffd, 0x3442ffff, -0x10000009, 0x2c2b024, 0x3c040001, 0x248462fc, -0x34a51100, 0x2003021, 0x3821, 0xafa00010, -0xc002b37, 0xafa00014, 0x8f4202cc, 0x24420001, -0xaf4202cc, 0x1000019f, 0x8f4202cc, 0x101302, -0x30450fff, 0x24020001, 0x10a20005, 0x24020002, -0x10a2000d, 0x3c0408ff, 0x10000014, 0x3c050003, -0x3c0208ff, 0x3442ffff, 0x8f830220, 0x3c040004, -0x2c4b025, 0x621824, 0x34630008, 0xaf830220, -0x10000012, 0xaf450298, 0x3484fff7, 0x3c03fffb, -0x8f820220, 0x3463ffff, 0x2c3b024, 0x441024, -0xaf820220, 0x10000009, 0xaf450298, 0x3c040001, -0x24846308, 0x34a51200, 0x2003021, 0x3821, -0xafa00010, 0xc002b37, 0xafa00014, 0x8f4202bc, -0x24420001, 0xaf4202bc, 0x10000176, 0x8f4202bc, -0x27840208, 0x24050200, 0xc002bbb, 0x24060008, -0x27440224, 0x24050200, 0xc002bbb, 0x24060008, -0x8f4202c4, 0x24420001, 0xaf4202c4, 0x10000169, -0x8f4202c4, 0x101302, 0x30430fff, 0x24020001, -0x10620011, 0x28620002, 0x50400005, 0x24020002, -0x10600007, 0x0, 0x10000017, 0x0, -0x1062000f, 0x0, 0x10000013, 0x0, -0x8c060248, 0x2021, 0xc005134, 0x24050004, -0x10000007, 0x0, 0x8c060248, 0x2021, -0xc005134, 0x24050004, 0x10000010, 0x0, -0x8c06024c, 0x2021, 0xc005134, 0x24050001, -0x1000000a, 0x0, 0x3c040001, 0x24846314, -0x3c050003, 0x34a51300, 0x2003021, 0x3821, -0xafa00010, 0xc002b37, 0xafa00014, 0x8f4202c0, -0x24420001, 0xaf4202c0, 0x1000013a, 0x8f4202c0, -0xc002426, 0x0, 0x10000136, 0x0, -0x24020001, 0xa34205c5, 0x24100100, 0x8f4401a8, -0x8f4501ac, 0xafb00010, 0xafa00014, 0x8f420014, -0xafa20018, 0x8f420108, 0x26e60028, 0x40f809, -0x24070400, 0x1040fff5, 0x0, 0x10000125, -0x0, 0x3c03ffff, 0x34637fff, 0x8f420368, -0x8f440360, 0x2c3b024, 0x1821, 0xaf400058, -0xaf40005c, 0xaf400060, 0xaf400064, 0x441023, -0xaf420368, 0x3c020900, 0xaf400360, 0xafa20020, +0xc002d3b, 0xafa00014, 0x8f4202a0, 0x24420001, +0xaf4202a0, 0x8f4202a0, 0x10000228, 0x0, +0x27b00028, 0x2002021, 0x24050210, 0xc002dbf, +0x24060008, 0xc00263a, 0x2002021, 0x1000021f, +0x0, 0x8faa0034, 0x27a40028, 0xa1880, +0x25420001, 0x3042003f, 0xafa20034, 0x8c650300, +0x8faa0034, 0x21080, 0x8c430300, 0x25420001, +0x3042003f, 0xafa20034, 0xac02022c, 0xafa50028, +0xc00263a, 0xafa3002c, 0x1000020c, 0x0, +0x27b00028, 0x2002021, 0x24050210, 0xc002dbf, +0x24060008, 0xc002779, 0x2002021, 0x10000203, +0x0, 0x8faa0034, 0x27a40028, 0xa1880, +0x25420001, 0x3042003f, 0xafa20034, 0x8c650300, +0x8faa0034, 0x21080, 0x8c430300, 0x25420001, +0x3042003f, 0xafa20034, 0xac02022c, 0xafa50028, +0xc002779, 0xafa3002c, 0x100001f0, 0x0, +0x101302, 0x30430fff, 0x24020001, 0x10620005, +0x24020002, 0x1062001e, 0x3c020002, 0x10000033, +0x3c050003, 0x3c030002, 0x2c31024, 0x54400037, +0x2c3b025, 0x8f820228, 0x3c010001, 0x370821, +0xac2238d8, 0x8f82022c, 0x3c010001, 0x370821, +0xac2238dc, 0x8f820230, 0x3c010001, 0x370821, +0xac2238e0, 0x8f820234, 0x3c010001, 0x370821, +0xac2238e4, 0x2402ffff, 0xaf820228, 0xaf82022c, +0xaf820230, 0xaf820234, 0x10000020, 0x2c3b025, +0x2c21024, 0x10400012, 0x3c02fffd, 0x3c020001, +0x571021, 0x8c4238d8, 0xaf820228, 0x3c020001, +0x571021, 0x8c4238dc, 0xaf82022c, 0x3c020001, +0x571021, 0x8c4238e0, 0xaf820230, 0x3c020001, +0x571021, 0x8c4238e4, 0xaf820234, 0x3c02fffd, +0x3442ffff, 0x10000009, 0x2c2b024, 0x3c040001, +0x248477c4, 0x34a51100, 0x2003021, 0x3821, +0xafa00010, 0xc002d3b, 0xafa00014, 0x8f4202cc, +0x24420001, 0xaf4202cc, 0x8f4202cc, 0x100001a7, +0x0, 0x101302, 0x30450fff, 0x24020001, +0x10a20005, 0x24020002, 0x10a2000e, 0x3c0408ff, +0x10000016, 0x3c050003, 0x3c0208ff, 0x3442ffff, +0x8f830220, 0x3c040004, 0x2c4b025, 0x621824, +0x34630008, 0xaf830220, 0xaf450298, 0x10000013, +0x0, 0x3484fff7, 0x3c03fffb, 0x8f820220, +0x3463ffff, 0x2c3b024, 0x441024, 0xaf820220, +0xaf450298, 0x10000009, 0x0, 0x3c040001, +0x248477d0, 0x34a51200, 0x2003021, 0x3821, +0xafa00010, 0xc002d3b, 0xafa00014, 0x8f4202bc, +0x24420001, 0xaf4202bc, 0x8f4202bc, 0x1000017b, +0x0, 0x27840208, 0x24050200, 0xc002dbf, +0x24060008, 0x27440224, 0x24050200, 0xc002dbf, +0x24060008, 0x8f4202c4, 0x24420001, 0xaf4202c4, +0x8f4202c4, 0x1000016d, 0x0, 0x101302, +0x30430fff, 0x24020001, 0x10620011, 0x28620002, +0x50400005, 0x24020002, 0x10600007, 0x0, +0x10000017, 0x0, 0x1062000f, 0x0, +0x10000013, 0x0, 0x8c060248, 0x2021, +0xc0056f1, 0x24050004, 0x10000007, 0x0, +0x8c060248, 0x2021, 0xc0056f1, 0x24050004, +0x10000010, 0x0, 0x8c06024c, 0x2021, +0xc0056f1, 0x24050001, 0x1000000a, 0x0, +0x3c040001, 0x248477dc, 0x3c050003, 0x34a51300, +0x2003021, 0x3821, 0xafa00010, 0xc002d3b, +0xafa00014, 0x8f4202c0, 0x24420001, 0xaf4202c0, +0x8f4202c0, 0x1000013d, 0x0, 0xc002548, +0x0, 0x10000139, 0x0, 0x24020001, +0xa34205c5, 0x24100100, 0x8f4401a8, 0x8f4501ac, +0xafb00010, 0xafa00014, 0x8f420014, 0xafa20018, +0x8f420108, 0x26e60028, 0x40f809, 0x24070400, +0x1040fff5, 0x0, 0x10000128, 0x0, +0x3c03ffff, 0x34637fff, 0x8f420368, 0x8f440360, +0x2c3b024, 0x1821, 0xaf400058, 0xaf40005c, +0xaf400060, 0xaf400064, 0x441023, 0xaf420368, +0x3c020900, 0xaf400360, 0xafa20020, 0x8f5e0018, +0x27aa0020, 0x240200ff, 0x13c20002, 0xafaa003c, +0x27c30001, 0x8c020228, 0x609021, 0x1642000e, +0x1e38c0, 0x8f42033c, 0x24420001, 0xaf42033c, +0x8f42033c, 0x8c020228, 0x3c040001, 0x24847774, +0x3c050009, 0xafa00014, 0xafa20010, 0x8fa60020, +0x1000006b, 0x34a50500, 0xf71021, 0x8fa30020, +0x8fa40024, 0xac4304c0, 0xac4404c4, 0x8f830054, +0x8f820054, 0x247003e8, 0x2021023, 0x2c4203e9, +0x1040001b, 0x9821, 0xe08821, 0x263504c0, +0x8f440178, 0x8f45017c, 0x2201821, 0x240a0004, +0xafaa0010, 0xafb20014, 0x8f48000c, 0x1021, +0x2f53021, 0xafa80018, 0x8f48010c, 0x24070008, +0xa32821, 0xa3482b, 0x822021, 0x100f809, +0x892021, 0x54400006, 0x24130001, 0x8f820054, +0x2021023, 0x2c4203e9, 0x1440ffe9, 0x0, +0x326200ff, 0x54400017, 0xaf520018, 0x8f420378, +0x24420001, 0xaf420378, 0x8f420378, 0x8f820120, +0x8faa003c, 0xafa20010, 0x8f820124, 0x3c040001, +0x24847780, 0x3c050009, 0xafa20014, 0x8d460000, +0x10000033, 0x34a50600, 0x8f420308, 0x24130001, +0x24420001, 0xaf420308, 0x8f420308, 0x1000001c, +0x326200ff, 0x8f830054, 0x8f820054, 0x247003e8, +0x2021023, 0x2c4203e9, 0x10400014, 0x9821, +0x24110010, 0x8f42000c, 0x8f440160, 0x8f450164, +0x8f860120, 0xafb10010, 0xafb20014, 0xafa20018, +0x8f42010c, 0x24070008, 0x40f809, 0x24c6001c, +0x1440ffe5, 0x0, 0x8f820054, 0x2021023, +0x2c4203e9, 0x1440ffef, 0x0, 0x326200ff, +0x14400011, 0x0, 0x8f420378, 0x24420001, +0xaf420378, 0x8f420378, 0x8f820120, 0x8faa003c, +0xafa20010, 0x8f820124, 0x3c040001, 0x24847788, +0x3c050009, 0xafa20014, 0x8d460000, 0x34a50700, +0xc002d3b, 0x3c03821, 0x8f4202b0, 0x24420001, +0xaf4202b0, 0x8f4202b0, 0x8f4202f8, 0x24420001, +0xaf4202f8, 0x8f4202f8, 0x1000008c, 0x0, +0x8c02025c, 0x27440224, 0xaf4201f0, 0x8c020260, +0x24050200, 0x24060008, 0xaf4201f8, 0xc002dbf, +0x0, 0x8f820220, 0x30420008, 0x14400002, +0x24020001, 0x24020002, 0xaf420298, 0x8f4202ac, +0x24420001, 0xaf4202ac, 0x8f4202ac, 0x10000077, +0x0, 0x3c0200ff, 0x3442ffff, 0x2021824, +0x32c20180, 0x14400006, 0x3402fffb, 0x43102b, +0x14400003, 0x0, 0x1000006c, 0xaf4300bc, +0x3c040001, 0x248477e8, 0x3c050003, 0x34a51500, +0x2003021, 0x3821, 0xafa00010, 0xc002d3b, +0xafa00014, 0x3c020700, 0x34421000, 0x101e02, +0x621825, 0xafa30020, 0x8f510018, 0x240200ff, +0x12220002, 0x8021, 0x26300001, 0x8c020228, +0x1602000e, 0x1130c0, 0x8f42033c, 0x24420001, +0xaf42033c, 0x8f42033c, 0x8c020228, 0x3c040001, +0x2484775c, 0x3c050009, 0xafa00014, 0xafa20010, +0x8fa60020, 0x1000003f, 0x34a50100, 0xd71021, +0x8fa30020, 0x8fa40024, 0xac4304c0, 0xac4404c4, +0xc01821, 0x8f440178, 0x8f45017c, 0x1021, +0x24070004, 0xafa70010, 0xafb00014, 0x8f48000c, +0x24c604c0, 0x2e63021, 0xafa80018, 0x8f48010c, +0x24070008, 0xa32821, 0xa3482b, 0x822021, +0x100f809, 0x892021, 0x1440000b, 0x24070008, +0x8f820120, 0xafa20010, 0x8f820124, 0x3c040001, +0x24847764, 0x3c050009, 0xafa20014, 0x8fa60020, +0x1000001c, 0x34a50200, 0x8f440160, 0x8f450164, +0x8f43000c, 0xaf500018, 0x8f860120, 0x24020010, +0xafa20010, 0xafb00014, 0xafa30018, 0x8f42010c, +0x40f809, 0x24c6001c, 0x14400010, 0x0, +0x8f420340, 0x24420001, 0xaf420340, 0x8f420340, +0x8f820120, 0xafa20010, 0x8f820124, 0x3c040001, +0x2484776c, 0x3c050009, 0xafa20014, 0x8fa60020, +0x34a50300, 0xc002d3b, 0x2203821, 0x8f4202e0, +0x24420001, 0xaf4202e0, 0x8f4202e0, 0x8f4202f0, +0x24420001, 0xaf4202f0, 0x8f4202f0, 0x8fa20034, +0x8fbf0058, 0x8fbe0054, 0x8fb50050, 0x8fb3004c, +0x8fb20048, 0x8fb10044, 0x8fb00040, 0x3e00008, +0x27bd0060, 0x27bdfff8, 0x2408ffff, 0x10a00014, +0x4821, 0x3c0aedb8, 0x354a8320, 0x90870000, +0x24840001, 0x3021, 0x1071026, 0x30420001, +0x10400002, 0x81842, 0x6a1826, 0x604021, +0x24c60001, 0x2cc20008, 0x1440fff7, 0x73842, +0x25290001, 0x125102b, 0x1440fff0, 0x0, +0x1001021, 0x3e00008, 0x27bd0008, 0x27bdffb0, +0xafbf0048, 0xafbe0044, 0xafb50040, 0xafb3003c, +0xafb20038, 0xafb10034, 0xafb00030, 0x8f870220, +0xafa70024, 0x8f870200, 0xafa7002c, 0x8f820220, +0x3c0308ff, 0x3463ffff, 0x431024, 0x34420004, +0xaf820220, 0x8f820200, 0x3c03c0ff, 0x3463ffff, +0x431024, 0x34420004, 0xaf820200, 0x8f530358, +0x8f55035c, 0x8f5e0360, 0x8f470364, 0xafa70014, +0x8f470368, 0xafa7001c, 0x8f4202d0, 0x274401c0, +0x24420001, 0xaf4202d0, 0x8f5002d0, 0x8f510204, +0x8f520200, 0xc002da8, 0x24050400, 0xaf530358, +0xaf55035c, 0xaf5e0360, 0x8fa70014, 0xaf470364, +0x8fa7001c, 0xaf470368, 0xaf5002d0, 0xaf510204, +0xaf520200, 0x8c02025c, 0x27440224, 0xaf4201f0, +0x8c020260, 0x24050200, 0x24060008, 0xaf4201f8, +0x24020006, 0xaf4201f4, 0xc002dbf, 0x0, +0x3c023b9a, 0x3442ca00, 0xaf4201fc, 0x240203e8, +0x24040002, 0x24030001, 0xaf420294, 0xaf440290, +0xaf43029c, 0x8f820220, 0x30420008, 0x10400004, +0x0, 0xaf430298, 0x10000003, 0x3021, +0xaf440298, 0x3021, 0x3c030002, 0x661821, +0x9063844c, 0x3461021, 0x24c60001, 0xa043022c, +0x2cc2000f, 0x1440fff8, 0x3461821, 0x24c60001, +0x8f820040, 0x24040080, 0x24050080, 0x21702, +0x24420030, 0xa062022c, 0x3461021, 0xa040022c, +0xc002da8, 0x0, 0x8fa70024, 0x30e20004, +0x14400006, 0x0, 0x8f820220, 0x3c0308ff, +0x3463fffb, 0x431024, 0xaf820220, 0x8fa7002c, +0x30e20004, 0x14400006, 0x0, 0x8f820200, +0x3c03c0ff, 0x3463fffb, 0x431024, 0xaf820200, +0x8fbf0048, 0x8fbe0044, 0x8fb50040, 0x8fb3003c, +0x8fb20038, 0x8fb10034, 0x8fb00030, 0x3e00008, +0x27bd0050, 0xaf400104, 0x24040001, 0x410c0, +0x2e21821, 0x24820001, 0x3c010001, 0x230821, +0xa42234d0, 0x402021, 0x2c820080, 0x1440fff8, +0x410c0, 0x24020001, 0x3c010001, 0x370821, +0xa42038d0, 0xaf420100, 0xaf800228, 0xaf80022c, +0xaf800230, 0xaf800234, 0x3e00008, 0x0, +0x27bdffe8, 0xafbf0014, 0xafb00010, 0x8f420104, +0x28420005, 0x10400026, 0x808021, 0x3c020001, +0x8f430104, 0x344230d0, 0x2e23021, 0x318c0, +0x621821, 0x2e33821, 0xc7102b, 0x10400015, +0x1021, 0x96080000, 0x24c40006, 0x9482fffc, +0x14480009, 0x2821, 0x9483fffe, 0x96020002, +0x14620006, 0xa01021, 0x94820000, 0x96030004, +0x431026, 0x2c450001, 0xa01021, 0x1440000a, +0x24c60008, 0xc7102b, 0x1440fff0, 0x24840008, +0x1021, 0x304200ff, 0x14400030, 0x24020001, +0x1000002e, 0x1021, 0x1000fffa, 0x24020001, +0x2002021, 0xc00252e, 0x24050006, 0x3042007f, +0x218c0, 0x2e31021, 0x3c010001, 0x220821, +0x942230d0, 0x1040fff2, 0x2e31021, 0x3c060001, +0xc23021, 0x94c630d0, 0x10c0ffed, 0x3c080001, +0x350834d2, 0x96070000, 0x610c0, 0x572021, +0x882021, 0x94820000, 0x14470009, 0x2821, +0x94830002, 0x96020002, 0x14620006, 0xa01021, +0x94820004, 0x96030004, 0x431026, 0x2c450001, +0xa01021, 0x14400007, 0x610c0, 0x2e21021, +0x3c060001, 0xc23021, 0x94c634d0, 0x14c0ffeb, +0x610c0, 0x10c0ffd2, 0x24020001, 0x8fbf0014, +0x8fb00010, 0x3e00008, 0x27bd0018, 0x3e00008, +0x0, 0x27bdffb0, 0x801021, 0xafb00030, +0x24500002, 0x2002021, 0x24050006, 0xafb10034, +0x408821, 0xafbf0048, 0xafbe0044, 0xafb50040, +0xafb3003c, 0xc00252e, 0xafb20038, 0x3047007f, +0x710c0, 0x2e21021, 0x3c050001, 0xa22821, +0x94a530d0, 0x50a0001c, 0xa03021, 0x3c090001, +0x352934d2, 0x96280002, 0x510c0, 0x572021, +0x892021, 0x94820000, 0x14480009, 0x3021, +0x94830002, 0x96020002, 0x14620006, 0xc01021, +0x94820004, 0x96030004, 0x431026, 0x2c460001, +0xc01021, 0x14400007, 0x510c0, 0x2e21021, +0x3c050001, 0xa22821, 0x94a534d0, 0x14a0ffeb, +0x510c0, 0xa03021, 0x10c00014, 0x610c0, +0x571821, 0x3c010001, 0x230821, 0x8c2334d0, +0x571021, 0xafa30010, 0x3c010001, 0x220821, +0x8c2234d4, 0x3c040001, 0x248478f0, 0xafa20014, +0x8e260000, 0x8e270004, 0x3c050004, 0xc002d3b, +0x34a50400, 0x10000063, 0x3c020800, 0x8f450100, +0x10a00006, 0x510c0, 0x2e21021, 0x3c010001, +0x220821, 0x942234d0, 0xaf420100, 0xa03021, +0x14c00011, 0x628c0, 0x710c0, 0x2e21021, +0xafa70010, 0x3c010001, 0x220821, 0x942230d0, +0x3c040001, 0x248478fc, 0xafa20014, 0x8e260000, +0x8e270004, 0x3c050004, 0xc002d3b, 0x34a50500, +0x10000048, 0x3c020800, 0xb71821, 0x3c020001, +0x96040000, 0x344234d2, 0x621821, 0xa4640000, +0x8e020002, 0x720c0, 0xac620002, 0x2e41021, +0x3c030001, 0x621821, 0x946330d0, 0x2e51021, +0x3c010001, 0x220821, 0xa42334d0, 0x2e41021, +0x3c010001, 0x220821, 0xa42630d0, 0x8f420104, +0x24420001, 0x28420080, 0x1040000f, 0x3c020002, +0x8f420104, 0x3c040001, 0x348430d2, 0x96030000, +0x210c0, 0x571021, 0x441021, 0xa4430000, +0x8e030002, 0xac430002, 0x8f420104, 0x24420001, +0xaf420104, 0x3c020002, 0x2c21024, 0x10400011, +0x72142, 0x3c030001, 0x346338d8, 0x24020003, +0x441023, 0x21080, 0x572021, 0x832021, +0x571021, 0x431021, 0x30e5001f, 0x8c430000, +0x24020001, 0xa21004, 0x621825, 0x1000000c, +0xac830000, 0x24020003, 0x441023, 0x21080, +0x5c2821, 0x5c1021, 0x30e4001f, 0x8c430228, +0x24020001, 0x821004, 0x621825, 0xaca30228, +0x3c020800, 0x34421000, 0x1821, 0xafa20020, 0x8f5e0018, 0x27aa0020, 0x240200ff, 0x13c20002, -0xafaa003c, 0x27c30001, 0x8c020228, 0x609021, +0xafaa002c, 0x27c30001, 0x8c020228, 0x609021, 0x1642000e, 0x1e38c0, 0x8f42033c, 0x24420001, 0xaf42033c, 0x8f42033c, 0x8c020228, 0x3c040001, -0x248462ac, 0x3c050009, 0xafa00014, 0xafa20010, +0x248478b8, 0x3c050009, 0xafa00014, 0xafa20010, 0x8fa60020, 0x1000006b, 0x34a50500, 0xf71021, 0x8fa30020, 0x8fa40024, 0xac4304c0, 0xac4404c4, 0x8f830054, 0x8f820054, 0x247003e8, 0x2021023, @@ -1253,8 +1501,8 @@ 0x8f820054, 0x2021023, 0x2c4203e9, 0x1440ffe9, 0x0, 0x326200ff, 0x54400017, 0xaf520018, 0x8f420378, 0x24420001, 0xaf420378, 0x8f420378, -0x8f820120, 0x8faa003c, 0xafa20010, 0x8f820124, -0x3c040001, 0x248462b8, 0x3c050009, 0xafa20014, +0x8f820120, 0x8faa002c, 0xafa20010, 0x8f820124, +0x3c040001, 0x248478c4, 0x3c050009, 0xafa20014, 0x8d460000, 0x10000033, 0x34a50600, 0x8f420308, 0x24130001, 0x24420001, 0xaf420308, 0x8f420308, 0x1000001c, 0x326200ff, 0x8f830054, 0x8f820054, @@ -1266,484 +1514,359 @@ 0x2021023, 0x2c4203e9, 0x1440ffef, 0x0, 0x326200ff, 0x14400011, 0x0, 0x8f420378, 0x24420001, 0xaf420378, 0x8f420378, 0x8f820120, -0x8faa003c, 0xafa20010, 0x8f820124, 0x3c040001, -0x248462c0, 0x3c050009, 0xafa20014, 0x8d460000, -0x34a50700, 0xc002b37, 0x3c03821, 0x8f4202b0, -0x24420001, 0xaf4202b0, 0x8f4202b0, 0x8f4202f8, -0x24420001, 0xaf4202f8, 0x1000008a, 0x8f4202f8, -0x8c02025c, 0x27440224, 0xaf4201f0, 0x8c020260, -0x24050200, 0x24060008, 0xc002bbb, 0xaf4201f8, -0x8f820220, 0x30420008, 0x14400002, 0x24020001, -0x24020002, 0xaf420298, 0x8f4202ac, 0x24420001, -0xaf4202ac, 0x10000077, 0x8f4202ac, 0x3c0200ff, -0x3442ffff, 0x2021824, 0x32c20180, 0x14400006, -0x3402fffb, 0x43102b, 0x14400003, 0x0, -0x1000006c, 0xaf4300bc, 0x3c040001, 0x24846320, -0x3c050003, 0x34a51500, 0x2003021, 0x3821, -0xafa00010, 0xc002b37, 0xafa00014, 0x3c020700, -0x34421000, 0x101e02, 0x621825, 0xafa30020, -0x8f510018, 0x240200ff, 0x12220002, 0x8021, -0x26300001, 0x8c020228, 0x1602000e, 0x1130c0, +0x8faa002c, 0xafa20010, 0x8f820124, 0x3c040001, +0x248478cc, 0x3c050009, 0xafa20014, 0x8d460000, +0x34a50700, 0xc002d3b, 0x3c03821, 0x8f4202b4, +0x24420001, 0xaf4202b4, 0x8f4202b4, 0x8f4202f4, +0x24420001, 0xaf4202f4, 0x8f4202f4, 0x8fbf0048, +0x8fbe0044, 0x8fb50040, 0x8fb3003c, 0x8fb20038, +0x8fb10034, 0x8fb00030, 0x3e00008, 0x27bd0050, +0x27bdffa0, 0x801021, 0xafb00040, 0x24500002, +0x2002021, 0x24050006, 0xafb10044, 0x408821, +0xafbf0058, 0xafbe0054, 0xafb50050, 0xafb3004c, +0xc00252e, 0xafb20048, 0x3048007f, 0x810c0, +0x2e21021, 0x3c060001, 0xc23021, 0x94c630d0, +0x10c0001c, 0x3821, 0x3c0a0001, 0x354a34d2, +0x96290002, 0x610c0, 0x572021, 0x8a2021, +0x94820000, 0x14490009, 0x2821, 0x94830002, +0x96020002, 0x14620006, 0xa01021, 0x94820004, +0x96030004, 0x431026, 0x2c450001, 0xa01021, +0x14400008, 0x610c0, 0xc03821, 0x2e21021, +0x3c060001, 0xc23021, 0x94c634d0, 0x14c0ffea, +0x610c0, 0x14c00011, 0xafa70028, 0x810c0, +0x2e21021, 0xafa80010, 0x3c010001, 0x220821, +0x942230d0, 0x3c040001, 0x24847908, 0xafa20014, +0x8e260000, 0x8e270004, 0x3c050004, 0xc002d3b, +0x34a50900, 0x10000075, 0x3c020800, 0x10e0000c, +0x610c0, 0x2e21021, 0x3c030001, 0x621821, +0x946334d0, 0x710c0, 0x2e21021, 0x3c010001, +0x220821, 0xa42334d0, 0x1000000b, 0x3c040001, +0x2e21021, 0x3c030001, 0x621821, 0x946334d0, +0x810c0, 0x2e21021, 0x3c010001, 0x220821, +0xa42330d0, 0x3c040001, 0x348430d0, 0x8f430100, +0x610c0, 0x2e21021, 0x3c010001, 0x220821, +0xa42334d0, 0x8f420104, 0x2e43821, 0x2821, +0x18400029, 0xaf460100, 0x24e60006, 0x94c3fffc, +0x96020000, 0x14620009, 0x2021, 0x94c3fffe, +0x96020002, 0x14620006, 0x801021, 0x94c20000, +0x96030004, 0x431026, 0x2c440001, 0x801021, +0x50400014, 0x24a50001, 0x8f420104, 0x2442ffff, +0xa2102a, 0x1040000b, 0x24e40004, 0x94820006, +0x8c830008, 0xa482fffe, 0xac830000, 0x8f420104, +0x24a50001, 0x2442ffff, 0xa2102a, 0x1440fff7, +0x24840008, 0x8f420104, 0x2442ffff, 0x10000006, +0xaf420104, 0x8f420104, 0x24c60008, 0xa2102a, +0x1440ffda, 0x24e70008, 0x810c0, 0x2e21021, +0x3c010001, 0x220821, 0x942230d0, 0x14400023, +0x3c020800, 0x3c020002, 0x2c21024, 0x10400012, +0x82142, 0x3c030001, 0x346338d8, 0x24020003, +0x441023, 0x21080, 0x572021, 0x832021, +0x571021, 0x431021, 0x3105001f, 0x24030001, +0x8c420000, 0xa31804, 0x31827, 0x431024, +0x1000000d, 0xac820000, 0x24020003, 0x441023, +0x21080, 0x5c2821, 0x5c1021, 0x3104001f, +0x24030001, 0x8c420228, 0x831804, 0x31827, +0x431024, 0xaca20228, 0x3c020800, 0x34422000, +0x1821, 0xafa20020, 0x8f5e0018, 0x27ab0020, +0x240200ff, 0x13c20002, 0xafab0034, 0x27c30001, +0x8c020228, 0x609021, 0x1642000e, 0x1e38c0, 0x8f42033c, 0x24420001, 0xaf42033c, 0x8f42033c, -0x8c020228, 0x3c040001, 0x24846294, 0x3c050009, -0xafa00014, 0xafa20010, 0x8fa60020, 0x1000003f, -0x34a50100, 0xd71021, 0x8fa30020, 0x8fa40024, -0xac4304c0, 0xac4404c4, 0xc01821, 0x8f440178, -0x8f45017c, 0x1021, 0x24070004, 0xafa70010, -0xafb00014, 0x8f48000c, 0x24c604c0, 0x2e63021, +0x8c020228, 0x3c040001, 0x248478b8, 0x3c050009, +0xafa00014, 0xafa20010, 0x8fa60020, 0x1000006b, +0x34a50500, 0xf71021, 0x8fa30020, 0x8fa40024, +0xac4304c0, 0xac4404c4, 0x8f830054, 0x8f820054, +0x247003e8, 0x2021023, 0x2c4203e9, 0x1040001b, +0x9821, 0xe08821, 0x263504c0, 0x8f440178, +0x8f45017c, 0x2201821, 0x240b0004, 0xafab0010, +0xafb20014, 0x8f48000c, 0x1021, 0x2f53021, 0xafa80018, 0x8f48010c, 0x24070008, 0xa32821, 0xa3482b, 0x822021, 0x100f809, 0x892021, -0x1440000b, 0x24070008, 0x8f820120, 0xafa20010, -0x8f820124, 0x3c040001, 0x2484629c, 0x3c050009, -0xafa20014, 0x8fa60020, 0x1000001c, 0x34a50200, -0x8f440160, 0x8f450164, 0x8f43000c, 0xaf500018, -0x8f860120, 0x24020010, 0xafa20010, 0xafb00014, -0xafa30018, 0x8f42010c, 0x40f809, 0x24c6001c, -0x14400010, 0x0, 0x8f420340, 0x24420001, -0xaf420340, 0x8f420340, 0x8f820120, 0xafa20010, -0x8f820124, 0x3c040001, 0x248462a4, 0x3c050009, -0xafa20014, 0x8fa60020, 0x34a50300, 0xc002b37, -0x2203821, 0x8f4202e0, 0x24420001, 0xaf4202e0, -0x8f4202e0, 0x8f4202f0, 0x24420001, 0xaf4202f0, -0x8f4202f0, 0x8fa20034, 0x8fbf0058, 0x8fbe0054, -0x8fb50050, 0x8fb3004c, 0x8fb20048, 0x8fb10044, -0x8fb00040, 0x3e00008, 0x27bd0060, 0x27bdfff8, -0x2408ffff, 0x10a00014, 0x4821, 0x3c0aedb8, -0x354a8320, 0x90870000, 0x24840001, 0x3021, -0x1071026, 0x30420001, 0x10400002, 0x81842, -0x6a1826, 0x604021, 0x24c60001, 0x2cc20008, -0x1440fff7, 0x73842, 0x25290001, 0x125102b, -0x1440fff0, 0x0, 0x1001021, 0x3e00008, -0x27bd0008, 0x27bdffb0, 0xafbf0048, 0xafbe0044, -0xafb50040, 0xafb3003c, 0xafb20038, 0xafb10034, -0xafb00030, 0x8f870220, 0xafa70024, 0x8f870200, -0xafa7002c, 0x8f820220, 0x3c0308ff, 0x3463ffff, -0x431024, 0x34420004, 0xaf820220, 0x8f820200, -0x3c03c0ff, 0x3463ffff, 0x431024, 0x34420004, -0xaf820200, 0x8f530358, 0x8f55035c, 0x8f5e0360, -0x8f470364, 0xafa70014, 0x8f470368, 0xafa7001c, -0x8f4202d0, 0x274401c0, 0x24420001, 0xaf4202d0, -0x8f5002d0, 0x8f510204, 0x8f520200, 0xc002ba4, -0x24050400, 0xaf530358, 0xaf55035c, 0xaf5e0360, -0x8fa70014, 0xaf470364, 0x8fa7001c, 0xaf470368, -0xaf5002d0, 0xaf510204, 0xaf520200, 0x8c02025c, -0x27440224, 0xaf4201f0, 0x8c020260, 0x24050200, -0x24060008, 0xaf4201f8, 0x24020006, 0xc002bbb, -0xaf4201f4, 0x3c023b9a, 0x3442ca00, 0xaf4201fc, -0x240203e8, 0x24040002, 0x24030001, 0xaf420294, -0xaf440290, 0xaf43029c, 0x8f820220, 0x30420008, -0x10400004, 0x0, 0xaf430298, 0x10000003, -0x3021, 0xaf440298, 0x3021, 0x3c030001, -0x661821, 0x90636dc0, 0x3461021, 0x24c60001, -0xa043022c, 0x2cc2000f, 0x1440fff8, 0x3461821, -0x24c60001, 0x8f820040, 0x24040080, 0x24050080, -0x21702, 0x24420030, 0xa062022c, 0x3461021, -0xc002ba4, 0xa040022c, 0x8fa70024, 0x30e20004, -0x14400006, 0x0, 0x8f820220, 0x3c0308ff, -0x3463fffb, 0x431024, 0xaf820220, 0x8fa7002c, -0x30e20004, 0x14400006, 0x0, 0x8f820200, -0x3c03c0ff, 0x3463fffb, 0x431024, 0xaf820200, -0x8fbf0048, 0x8fbe0044, 0x8fb50040, 0x8fb3003c, -0x8fb20038, 0x8fb10034, 0x8fb00030, 0x3e00008, -0x27bd0050, 0x0, 0x0, 0xaf400104, -0x24040001, 0x410c0, 0x2e21821, 0x24820001, -0x3c010001, 0x230821, 0xa42234d0, 0x402021, -0x2c820080, 0x1440fff8, 0x410c0, 0x24020001, -0x3c010001, 0x370821, 0xa42038d0, 0xaf420100, -0xaf800228, 0xaf80022c, 0xaf800230, 0x3e00008, -0xaf800234, 0x27bdffe8, 0xafbf0014, 0xafb00010, -0x8f420104, 0x28420005, 0x10400026, 0x808021, -0x3c020001, 0x8f430104, 0x344230d0, 0x2e22021, -0x318c0, 0x621821, 0x2e31821, 0x83102b, -0x10400015, 0x1021, 0x96070000, 0x24840006, -0x24660006, 0x9482fffc, 0x14470009, 0x2821, -0x9483fffe, 0x96020002, 0x14620006, 0xa01021, -0x94820000, 0x96030004, 0x431026, 0x2c450001, -0xa01021, 0x14400009, 0x24840008, 0x86102b, -0x1440fff0, 0x1021, 0x304200ff, 0x14400030, -0x24020001, 0x1000002e, 0x1021, 0x1000fffa, -0x24020001, 0x2002021, 0xc00240c, 0x24050006, -0x3042007f, 0x218c0, 0x2e31021, 0x3c010001, -0x220821, 0x942230d0, 0x1040fff2, 0x2e31021, -0x3c060001, 0xc23021, 0x94c630d0, 0x10c0ffed, -0x3c080001, 0x350834d2, 0x96070000, 0x610c0, -0x572021, 0x882021, 0x94820000, 0x14470009, -0x2821, 0x94830002, 0x96020002, 0x14620006, -0xa01021, 0x94820004, 0x96030004, 0x431026, -0x2c450001, 0xa01021, 0x14400007, 0x610c0, -0x2e21021, 0x3c060001, 0xc23021, 0x94c634d0, -0x14c0ffeb, 0x610c0, 0x10c0ffd2, 0x24020001, -0x8fbf0014, 0x8fb00010, 0x3e00008, 0x27bd0018, -0x3e00008, 0x0, 0x27bdffb0, 0x801021, -0xafb00030, 0x24500002, 0x2002021, 0x24050006, -0xafb10034, 0x408821, 0xafbf0048, 0xafbe0044, -0xafb50040, 0xafb3003c, 0xc00240c, 0xafb20038, -0x3047007f, 0x710c0, 0x2e21021, 0x3c050001, -0xa22821, 0x94a530d0, 0x50a0001c, 0xa03021, -0x3c090001, 0x352934d2, 0x96280002, 0x510c0, -0x572021, 0x892021, 0x94820000, 0x14480009, -0x3021, 0x94830002, 0x96020002, 0x14620006, -0xc01021, 0x94820004, 0x96030004, 0x431026, -0x2c460001, 0xc01021, 0x14400007, 0x510c0, -0x2e21021, 0x3c050001, 0xa22821, 0x94a534d0, -0x14a0ffeb, 0x510c0, 0xa03021, 0x10c00014, -0x610c0, 0x571821, 0x3c010001, 0x230821, -0x8c2334d0, 0x571021, 0xafa30010, 0x3c010001, -0x220821, 0x8c2234d4, 0x3c040001, 0x24846434, -0xafa20014, 0x8e260000, 0x8e270004, 0x3c050004, -0xc002b37, 0x34a50400, 0x10000063, 0x3c020800, -0x8f450100, 0x10a00006, 0x510c0, 0x2e21021, -0x3c010001, 0x220821, 0x942234d0, 0xaf420100, -0xa03021, 0x14c00011, 0x628c0, 0x710c0, -0x2e21021, 0xafa70010, 0x3c010001, 0x220821, -0x942230d0, 0x3c040001, 0x24846440, 0xafa20014, -0x8e260000, 0x8e270004, 0x3c050004, 0xc002b37, -0x34a50500, 0x10000048, 0x3c020800, 0xb71821, -0x3c020001, 0x96040000, 0x344234d2, 0x621821, -0xa4640000, 0x8e020002, 0x720c0, 0xac620002, -0x2e41021, 0x3c030001, 0x621821, 0x946330d0, -0x2e51021, 0x3c010001, 0x220821, 0xa42334d0, -0x2e41021, 0x3c010001, 0x220821, 0xa42630d0, -0x8f420104, 0x24420001, 0x28420080, 0x1040000f, -0x3c020002, 0x8f420104, 0x3c040001, 0x348430d2, -0x96030000, 0x210c0, 0x571021, 0x441021, -0xa4430000, 0x8e030002, 0xac430002, 0x8f420104, -0x24420001, 0xaf420104, 0x3c020002, 0x2c21024, -0x10400011, 0x72142, 0x3c030001, 0x346338d8, -0x24020003, 0x441023, 0x21080, 0x572021, -0x832021, 0x571021, 0x431021, 0x30e5001f, -0x8c430000, 0x24020001, 0xa21004, 0x621825, -0x1000000c, 0xac830000, 0x24020003, 0x441023, -0x21080, 0x5c2821, 0x5c1021, 0x30e4001f, -0x8c430228, 0x24020001, 0x821004, 0x621825, -0xaca30228, 0x3c020800, 0x34421000, 0x1821, -0xafa20020, 0x8f5e0018, 0x27aa0020, 0x240200ff, -0x13c20002, 0xafaa002c, 0x27c30001, 0x8c020228, -0x609021, 0x1642000e, 0x1e38c0, 0x8f42033c, -0x24420001, 0xaf42033c, 0x8f42033c, 0x8c020228, -0x3c040001, 0x248463fc, 0x3c050009, 0xafa00014, -0xafa20010, 0x8fa60020, 0x1000006b, 0x34a50500, -0xf71021, 0x8fa30020, 0x8fa40024, 0xac4304c0, -0xac4404c4, 0x8f830054, 0x8f820054, 0x247003e8, -0x2021023, 0x2c4203e9, 0x1040001b, 0x9821, -0xe08821, 0x263504c0, 0x8f440178, 0x8f45017c, -0x2201821, 0x240a0004, 0xafaa0010, 0xafb20014, -0x8f48000c, 0x1021, 0x2f53021, 0xafa80018, -0x8f48010c, 0x24070008, 0xa32821, 0xa3482b, -0x822021, 0x100f809, 0x892021, 0x54400006, -0x24130001, 0x8f820054, 0x2021023, 0x2c4203e9, -0x1440ffe9, 0x0, 0x326200ff, 0x54400017, -0xaf520018, 0x8f420378, 0x24420001, 0xaf420378, -0x8f420378, 0x8f820120, 0x8faa002c, 0xafa20010, -0x8f820124, 0x3c040001, 0x24846408, 0x3c050009, -0xafa20014, 0x8d460000, 0x10000033, 0x34a50600, -0x8f420308, 0x24130001, 0x24420001, 0xaf420308, -0x8f420308, 0x1000001c, 0x326200ff, 0x8f830054, -0x8f820054, 0x247003e8, 0x2021023, 0x2c4203e9, -0x10400014, 0x9821, 0x24110010, 0x8f42000c, -0x8f440160, 0x8f450164, 0x8f860120, 0xafb10010, -0xafb20014, 0xafa20018, 0x8f42010c, 0x24070008, -0x40f809, 0x24c6001c, 0x1440ffe5, 0x0, -0x8f820054, 0x2021023, 0x2c4203e9, 0x1440ffef, -0x0, 0x326200ff, 0x14400011, 0x0, -0x8f420378, 0x24420001, 0xaf420378, 0x8f420378, -0x8f820120, 0x8faa002c, 0xafa20010, 0x8f820124, -0x3c040001, 0x24846410, 0x3c050009, 0xafa20014, -0x8d460000, 0x34a50700, 0xc002b37, 0x3c03821, -0x8f4202b4, 0x24420001, 0xaf4202b4, 0x8f4202b4, -0x8f4202f4, 0x24420001, 0xaf4202f4, 0x8f4202f4, -0x8fbf0048, 0x8fbe0044, 0x8fb50040, 0x8fb3003c, -0x8fb20038, 0x8fb10034, 0x8fb00030, 0x3e00008, -0x27bd0050, 0x27bdffa0, 0x801021, 0xafb00040, -0x24500002, 0x2002021, 0x24050006, 0xafb10044, -0x408821, 0xafbf0058, 0xafbe0054, 0xafb50050, -0xafb3004c, 0xc00240c, 0xafb20048, 0x3048007f, -0x810c0, 0x2e21021, 0x3c060001, 0xc23021, -0x94c630d0, 0x10c0001c, 0x3821, 0x3c0a0001, -0x354a34d2, 0x96290002, 0x610c0, 0x572021, -0x8a2021, 0x94820000, 0x14490009, 0x2821, -0x94830002, 0x96020002, 0x14620006, 0xa01021, -0x94820004, 0x96030004, 0x431026, 0x2c450001, -0xa01021, 0x14400008, 0x610c0, 0xc03821, -0x2e21021, 0x3c060001, 0xc23021, 0x94c634d0, -0x14c0ffea, 0x610c0, 0x14c00011, 0xafa70028, -0x810c0, 0x2e21021, 0xafa80010, 0x3c010001, -0x220821, 0x942230d0, 0x3c040001, 0x2484644c, -0xafa20014, 0x8e260000, 0x8e270004, 0x3c050004, -0xc002b37, 0x34a50900, 0x10000075, 0x3c020800, -0x10e0000c, 0x610c0, 0x2e21021, 0x3c030001, -0x621821, 0x946334d0, 0x710c0, 0x2e21021, -0x3c010001, 0x220821, 0xa42334d0, 0x1000000b, -0x3c040001, 0x2e21021, 0x3c030001, 0x621821, -0x946334d0, 0x810c0, 0x2e21021, 0x3c010001, -0x220821, 0xa42330d0, 0x3c040001, 0x348430d0, -0x8f430100, 0x610c0, 0x2e21021, 0x3c010001, -0x220821, 0xa42334d0, 0x8f420104, 0x2e43821, -0x2821, 0x18400029, 0xaf460100, 0x24e60006, -0x94c3fffc, 0x96020000, 0x14620009, 0x2021, -0x94c3fffe, 0x96020002, 0x14620006, 0x801021, -0x94c20000, 0x96030004, 0x431026, 0x2c440001, -0x801021, 0x50400014, 0x24a50001, 0x8f420104, -0x2442ffff, 0xa2102a, 0x1040000b, 0x24e40004, -0x94820006, 0x8c830008, 0xa482fffe, 0xac830000, -0x8f420104, 0x24a50001, 0x2442ffff, 0xa2102a, -0x1440fff7, 0x24840008, 0x8f420104, 0x2442ffff, -0x10000006, 0xaf420104, 0x8f420104, 0x24c60008, -0xa2102a, 0x1440ffda, 0x24e70008, 0x810c0, -0x2e21021, 0x3c010001, 0x220821, 0x942230d0, -0x14400023, 0x3c020800, 0x3c020002, 0x2c21024, -0x10400012, 0x82142, 0x3c030001, 0x346338d8, -0x24020003, 0x441023, 0x21080, 0x572021, -0x832021, 0x571021, 0x431021, 0x3105001f, -0x24030001, 0x8c420000, 0xa31804, 0x31827, -0x431024, 0x1000000d, 0xac820000, 0x24020003, -0x441023, 0x21080, 0x5c2821, 0x5c1021, -0x3104001f, 0x24030001, 0x8c420228, 0x831804, -0x31827, 0x431024, 0xaca20228, 0x3c020800, -0x34422000, 0x1821, 0xafa20020, 0x8f5e0018, -0x27ab0020, 0x240200ff, 0x13c20002, 0xafab0034, -0x27c30001, 0x8c020228, 0x609021, 0x1642000e, -0x1e38c0, 0x8f42033c, 0x24420001, 0xaf42033c, -0x8f42033c, 0x8c020228, 0x3c040001, 0x248463fc, -0x3c050009, 0xafa00014, 0xafa20010, 0x8fa60020, -0x1000006b, 0x34a50500, 0xf71021, 0x8fa30020, -0x8fa40024, 0xac4304c0, 0xac4404c4, 0x8f830054, -0x8f820054, 0x247003e8, 0x2021023, 0x2c4203e9, -0x1040001b, 0x9821, 0xe08821, 0x263504c0, -0x8f440178, 0x8f45017c, 0x2201821, 0x240b0004, -0xafab0010, 0xafb20014, 0x8f48000c, 0x1021, -0x2f53021, 0xafa80018, 0x8f48010c, 0x24070008, -0xa32821, 0xa3482b, 0x822021, 0x100f809, -0x892021, 0x54400006, 0x24130001, 0x8f820054, -0x2021023, 0x2c4203e9, 0x1440ffe9, 0x0, -0x326200ff, 0x54400017, 0xaf520018, 0x8f420378, -0x24420001, 0xaf420378, 0x8f420378, 0x8f820120, -0x8fab0034, 0xafa20010, 0x8f820124, 0x3c040001, -0x24846408, 0x3c050009, 0xafa20014, 0x8d660000, -0x10000033, 0x34a50600, 0x8f420308, 0x24130001, -0x24420001, 0xaf420308, 0x8f420308, 0x1000001c, -0x326200ff, 0x8f830054, 0x8f820054, 0x247003e8, -0x2021023, 0x2c4203e9, 0x10400014, 0x9821, -0x24110010, 0x8f42000c, 0x8f440160, 0x8f450164, -0x8f860120, 0xafb10010, 0xafb20014, 0xafa20018, -0x8f42010c, 0x24070008, 0x40f809, 0x24c6001c, -0x1440ffe5, 0x0, 0x8f820054, 0x2021023, -0x2c4203e9, 0x1440ffef, 0x0, 0x326200ff, -0x14400011, 0x0, 0x8f420378, 0x24420001, +0x54400006, 0x24130001, 0x8f820054, 0x2021023, +0x2c4203e9, 0x1440ffe9, 0x0, 0x326200ff, +0x54400017, 0xaf520018, 0x8f420378, 0x24420001, 0xaf420378, 0x8f420378, 0x8f820120, 0x8fab0034, -0xafa20010, 0x8f820124, 0x3c040001, 0x24846410, -0x3c050009, 0xafa20014, 0x8d660000, 0x34a50700, -0xc002b37, 0x3c03821, 0x8f4202b8, 0x24420001, -0xaf4202b8, 0x8f4202b8, 0x8f4202f4, 0x24420001, -0xaf4202f4, 0x8f4202f4, 0x8fbf0058, 0x8fbe0054, -0x8fb50050, 0x8fb3004c, 0x8fb20048, 0x8fb10044, -0x8fb00040, 0x3e00008, 0x27bd0060, 0x27bdffe0, -0x27644000, 0xafbf0018, 0xc002ba4, 0x24051000, -0x3c030001, 0x34632cc0, 0x3c040001, 0x34842ec8, -0x24020020, 0xaf82011c, 0x2e31021, 0xaf800100, -0xaf800104, 0xaf800108, 0xaf800110, 0xaf800114, -0xaf800118, 0xaf800120, 0xaf800124, 0xaf800128, -0xaf800130, 0xaf800134, 0xaf800138, 0xaf4200ec, -0x2e31021, 0xaf4200f0, 0x2e41021, 0xaf4200f4, -0x2e41021, 0xaf4200f8, 0x3c020001, 0x571021, -0x904240f4, 0x1440001c, 0x3c050001, 0x8f82011c, -0x3c040001, 0x24846510, 0x3c050001, 0x34420001, -0xaf82011c, 0xafa00010, 0xafa00014, 0x8f86011c, -0x34a50100, 0xc002b37, 0x3821, 0x8c020218, -0x30420040, 0x10400014, 0x0, 0x8f82011c, -0x3c040001, 0x2484651c, 0x3c050001, 0x34420004, -0xaf82011c, 0xafa00010, 0xafa00014, 0x8f86011c, -0x10000007, 0x34a50200, 0x3c040001, 0x24846524, -0xafa00010, 0xafa00014, 0x8f86011c, 0x34a50300, -0xc002b37, 0x3821, 0x8fbf0018, 0x3e00008, -0x27bd0020, 0x8fa90010, 0x8f83012c, 0x8faa0014, -0x8fab0018, 0x1060000a, 0x27624fe0, 0x14620002, -0x24680020, 0x27684800, 0x8f820128, 0x11020004, -0x0, 0x8f820124, 0x15020007, 0x0, -0x8f430334, 0x1021, 0x24630001, 0xaf430334, -0x10000039, 0x8f430334, 0xac640000, 0xac650004, -0xac660008, 0xa467000e, 0xac690018, 0xac6a001c, -0xac6b0010, 0xac620014, 0xaf880120, 0x8f4200fc, -0x8f4400f4, 0x2442ffff, 0xaf4200fc, 0x8c820000, -0x10490005, 0x3042ff8f, 0x10400019, 0x3122ff8f, -0x10400018, 0x3c020001, 0x8c830004, 0x2c620010, -0x10400013, 0x3c020001, 0x24630001, 0xac830004, +0xafa20010, 0x8f820124, 0x3c040001, 0x248478c4, +0x3c050009, 0xafa20014, 0x8d660000, 0x10000033, +0x34a50600, 0x8f420308, 0x24130001, 0x24420001, +0xaf420308, 0x8f420308, 0x1000001c, 0x326200ff, +0x8f830054, 0x8f820054, 0x247003e8, 0x2021023, +0x2c4203e9, 0x10400014, 0x9821, 0x24110010, +0x8f42000c, 0x8f440160, 0x8f450164, 0x8f860120, +0xafb10010, 0xafb20014, 0xafa20018, 0x8f42010c, +0x24070008, 0x40f809, 0x24c6001c, 0x1440ffe5, +0x0, 0x8f820054, 0x2021023, 0x2c4203e9, +0x1440ffef, 0x0, 0x326200ff, 0x14400011, +0x0, 0x8f420378, 0x24420001, 0xaf420378, +0x8f420378, 0x8f820120, 0x8fab0034, 0xafa20010, +0x8f820124, 0x3c040001, 0x248478cc, 0x3c050009, +0xafa20014, 0x8d660000, 0x34a50700, 0xc002d3b, +0x3c03821, 0x8f4202b8, 0x24420001, 0xaf4202b8, +0x8f4202b8, 0x8f4202f4, 0x24420001, 0xaf4202f4, +0x8f4202f4, 0x8fbf0058, 0x8fbe0054, 0x8fb50050, +0x8fb3004c, 0x8fb20048, 0x8fb10044, 0x8fb00040, +0x3e00008, 0x27bd0060, 0x27bdffe0, 0x27644000, +0xafbf0018, 0xc002da8, 0x24051000, 0x3c030001, +0x34632cc0, 0x3c040001, 0x34842ec8, 0x24020020, +0xaf82011c, 0x2e31021, 0xaf800100, 0xaf800104, +0xaf800108, 0xaf800110, 0xaf800114, 0xaf800118, +0xaf800120, 0xaf800124, 0xaf800128, 0xaf800130, +0xaf800134, 0xaf800138, 0xaf4200ec, 0x2e31021, +0xaf4200f0, 0x2e41021, 0xaf4200f4, 0x2e41021, +0xaf4200f8, 0x3c020001, 0x571021, 0x904240f4, +0x1440001c, 0x3c050001, 0x8f82011c, 0x3c040001, +0x248479c4, 0x3c050001, 0x34420001, 0xaf82011c, +0xafa00010, 0xafa00014, 0x8f86011c, 0x34a50100, +0xc002d3b, 0x3821, 0x8c020218, 0x30420040, +0x10400014, 0x0, 0x8f82011c, 0x3c040001, +0x248479d0, 0x3c050001, 0x34420004, 0xaf82011c, +0xafa00010, 0xafa00014, 0x8f86011c, 0x10000007, +0x34a50200, 0x3c040001, 0x248479d8, 0xafa00010, +0xafa00014, 0x8f86011c, 0x34a50300, 0xc002d3b, +0x3821, 0x8fbf0018, 0x3e00008, 0x27bd0020, +0x27bdffd8, 0xafb1001c, 0x8fb10038, 0xafbf0020, +0xafb00018, 0x8f83012c, 0x8fa9003c, 0x8faa0040, +0x1060000a, 0x27624fe0, 0x14620002, 0x24680020, +0x27684800, 0x8f820128, 0x11020004, 0x0, +0x8f820124, 0x15020008, 0x0, 0x8f430334, +0x1021, 0x24630001, 0xaf430334, 0x8f430334, +0x10000052, 0x0, 0xac640000, 0xac650004, +0xac660008, 0xa467000e, 0xac710018, 0xac69001c, +0xac6a0010, 0xac620014, 0xaf880120, 0x8f4200fc, +0x8f5000f4, 0x2442ffff, 0xaf4200fc, 0x8e020000, +0x10510005, 0x3042ff8f, 0x10400019, 0x3222ff8f, +0x10400018, 0x3c020001, 0x8e030004, 0x2c620010, +0x10400013, 0x3c020001, 0x24630001, 0xae030004, 0x8f4300f8, 0x344230c8, 0x2e21021, 0x54620004, 0x24620008, 0x3c020001, 0x34422ec8, 0x2e21021, -0x14440015, 0x24020001, 0x8f820128, 0x24420020, -0xaf820128, 0x8f820128, 0x1000000f, 0x24020001, -0x3c020001, 0x344230c8, 0x2e21021, 0x54820004, -0x24820008, 0x3c020001, 0x34422ec8, 0x2e21021, -0x402021, 0x24020001, 0xaf4400f4, 0xac890000, -0xac820004, 0x24020001, 0x3e00008, 0x0, -0x3e00008, 0x0, 0x8fa90010, 0x8f83010c, -0x8faa0014, 0x8fab0018, 0x1060000a, 0x276247e0, -0x14620002, 0x24680020, 0x27684000, 0x8f820108, -0x11020004, 0x0, 0x8f820104, 0x15020007, -0x0, 0x8f430338, 0x1021, 0x24630001, -0xaf430338, 0x10000035, 0x8f430338, 0xac640000, -0xac650004, 0xac660008, 0xa467000e, 0xac690018, -0xac6a001c, 0xac6b0010, 0xac620014, 0xaf880100, -0x8f4400ec, 0x8c820000, 0x30420006, 0x10400019, -0x31220006, 0x10400018, 0x3c020001, 0x8c830004, -0x2c620010, 0x10400013, 0x3c020001, 0x24630001, -0xac830004, 0x8f4300f0, 0x34422ec0, 0x2e21021, -0x54620004, 0x24620008, 0x3c020001, 0x34422cc0, -0x2e21021, 0x14440015, 0x24020001, 0x8f820108, -0x24420020, 0xaf820108, 0x8f820108, 0x1000000f, -0x24020001, 0x3c020001, 0x34422ec0, 0x2e21021, -0x54820004, 0x24820008, 0x3c020001, 0x34422cc0, -0x2e21021, 0x402021, 0x24020001, 0xaf4400ec, -0xac890000, 0xac820004, 0x24020001, 0x3e00008, -0x0, 0x3e00008, 0x0, 0x27bdffd8, -0x3c040001, 0x2484652c, 0x3c050001, 0xafbf0024, -0xafb20020, 0xafb1001c, 0xafb00018, 0x8f900104, -0x8f9100b0, 0x8f92011c, 0x34a52500, 0x8f820100, -0x2403021, 0x2203821, 0xafa20010, 0xc002b37, -0xafb00014, 0x8e020008, 0xafa20010, 0x8e02000c, -0x3c040001, 0x24846538, 0xafa20014, 0x8e060000, -0x8e070004, 0x3c050001, 0xc002b37, 0x34a52510, -0x8e020018, 0xafa20010, 0x8e02001c, 0x3c040001, -0x24846544, 0xafa20014, 0x8e060010, 0x8e070014, -0x3c050001, 0xc002b37, 0x34a52520, 0x3c027f00, -0x2221024, 0x3c030800, 0x54430016, 0x3c030200, -0x8f82009c, 0x3042ffff, 0x14400012, 0x3c030200, -0x3c040001, 0x24846550, 0x3c050002, 0x34a5f030, -0x3021, 0x3821, 0x36420002, 0xaf82011c, -0x36220001, 0xaf8200b0, 0xaf900104, 0xaf92011c, -0xafa00010, 0xc002b37, 0xafa00014, 0x10000024, -0x0, 0x2c31024, 0x1040000d, 0x2231024, -0x1040000b, 0x36420002, 0xaf82011c, 0x36220001, -0xaf8200b0, 0xaf900104, 0xaf92011c, 0x8f420330, -0x24420001, 0xaf420330, 0x10000015, 0x8f420330, -0x3c040001, 0x24846558, 0x240202a9, 0xafa20010, -0xafa00014, 0x8f860144, 0x3c070001, 0x24e76560, -0xc002b37, 0x3405dead, 0x8f82011c, 0x34420002, +0x1450002e, 0x24020001, 0x8f820128, 0x24420020, +0xaf820128, 0x8f820128, 0x10000028, 0x24020001, +0x3c020001, 0x344230c8, 0x2e21021, 0x16020004, +0x26030008, 0x3c020001, 0x34422ec8, 0x2e21821, +0x8f4200f8, 0x608021, 0x12020004, 0xaf5000f4, +0x8e020000, 0x10400016, 0x24020001, 0x24020170, +0x3c040001, 0x248479e0, 0xafa20010, 0xafa00014, +0x8f860144, 0x3c070001, 0x24e779e8, 0xc002d3b, +0x3405dead, 0x8f82011c, 0x34420002, 0xaf82011c, +0x8f820220, 0x34420004, 0xaf820220, 0x8f820140, +0x3c030001, 0x431025, 0xaf820140, 0x24020001, +0xae110000, 0xae020004, 0x24020001, 0x8fbf0020, +0x8fb1001c, 0x8fb00018, 0x3e00008, 0x27bd0028, +0x3e00008, 0x0, 0x27bdffc8, 0xafb30024, +0xafb20020, 0x809021, 0xa09821, 0xafb50028, +0xc0a821, 0xafbf0030, 0xafbe002c, 0xafb1001c, +0xafb00018, 0x8f900120, 0x27624fe0, 0x16020003, +0xe0f021, 0x10000002, 0x27714800, 0x26110020, +0x8f820128, 0x16220008, 0x0, 0x8f430334, +0x1021, 0x24630001, 0xaf430334, 0x8f430334, +0x10000028, 0x0, 0x8f820124, 0x16220014, +0x240201ab, 0x3c040001, 0x248479e0, 0xafa20010, +0xafa00014, 0x8f860144, 0x3c070001, 0x24e779e8, +0xc002d3b, 0x3405dead, 0x8f82011c, 0x34420002, 0xaf82011c, 0x8f820220, 0x34420004, 0xaf820220, 0x8f820140, 0x3c030001, 0x431025, 0xaf820140, -0x8fbf0024, 0x8fb20020, 0x8fb1001c, 0x8fb00018, -0x3e00008, 0x27bd0028, 0x27bdffd8, 0x3c040001, -0x24846568, 0x3c050001, 0xafbf0024, 0xafb20020, -0xafb1001c, 0xafb00018, 0x8f900124, 0x8f9100a0, -0x8f92011c, 0x34a52600, 0x8f820120, 0x2403021, -0x2203821, 0xafa20010, 0xc002b37, 0xafb00014, -0x8e020008, 0xafa20010, 0x8e02000c, 0x3c040001, -0x24846574, 0xafa20014, 0x8e060000, 0x8e070004, -0x3c050001, 0xc002b37, 0x34a52610, 0x8e020018, -0xafa20010, 0x8e02001c, 0x3c040001, 0x24846580, -0xafa20014, 0x8e060010, 0x8e070014, 0x3c050001, -0xc002b37, 0x34a52620, 0x3c027f00, 0x2221024, -0x3c030800, 0x54430016, 0x3c030200, 0x8f8200ac, -0x3042ffff, 0x14400012, 0x3c030200, 0x3c040001, -0x2484658c, 0x3c050001, 0x34a5f030, 0x3021, -0x3821, 0x36420002, 0xaf82011c, 0x36220001, -0xaf8200a0, 0xaf900124, 0xaf92011c, 0xafa00010, -0xc002b37, 0xafa00014, 0x10000024, 0x0, -0x2c31024, 0x1040000d, 0x2231024, 0x1040000b, +0xae120000, 0xae130004, 0xae150008, 0xa61e000e, +0x8fa80048, 0xae080018, 0x8fa8004c, 0x26020016, +0xae08001c, 0xae020014, 0x8fa80050, 0xae080010, +0xaf910120, 0x8f4300fc, 0x24020001, 0x2463ffff, +0xaf4300fc, 0x8fbf0030, 0x8fbe002c, 0x8fb50028, +0x8fb30024, 0x8fb20020, 0x8fb1001c, 0x8fb00018, +0x3e00008, 0x27bd0038, 0x3e00008, 0x0, +0x27bdffd8, 0xafb1001c, 0x8fb10038, 0xafbf0020, +0xafb00018, 0x8f83010c, 0x8fa9003c, 0x8faa0040, +0x1060000a, 0x276247e0, 0x14620002, 0x24680020, +0x27684000, 0x8f820108, 0x11020004, 0x0, +0x8f820104, 0x15020008, 0x0, 0x8f430338, +0x1021, 0x24630001, 0xaf430338, 0x8f430338, +0x1000004e, 0x0, 0xac640000, 0xac650004, +0xac660008, 0xa467000e, 0xac710018, 0xac69001c, +0xac6a0010, 0xac620014, 0xaf880100, 0x8f5000ec, +0x8e020000, 0x30420006, 0x10400019, 0x32220006, +0x10400018, 0x3c020001, 0x8e030004, 0x2c620010, +0x10400013, 0x3c020001, 0x24630001, 0xae030004, +0x8f4300f0, 0x34422ec0, 0x2e21021, 0x54620004, +0x24620008, 0x3c020001, 0x34422cc0, 0x2e21021, +0x1450002e, 0x24020001, 0x8f820108, 0x24420020, +0xaf820108, 0x8f820108, 0x10000028, 0x24020001, +0x3c020001, 0x34422ec0, 0x2e21021, 0x16020004, +0x26030008, 0x3c020001, 0x34422cc0, 0x2e21821, +0x8f4200f0, 0x608021, 0x12020004, 0xaf5000ec, +0x8e020000, 0x10400016, 0x24020001, 0x24020212, +0x3c040001, 0x248479e0, 0xafa20010, 0xafa00014, +0x8f860144, 0x3c070001, 0x24e779e8, 0xc002d3b, +0x3405dead, 0x8f82011c, 0x34420002, 0xaf82011c, +0x8f820220, 0x34420004, 0xaf820220, 0x8f820140, +0x3c030001, 0x431025, 0xaf820140, 0x24020001, +0xae110000, 0xae020004, 0x24020001, 0x8fbf0020, +0x8fb1001c, 0x8fb00018, 0x3e00008, 0x27bd0028, +0x3e00008, 0x0, 0x27bdffc8, 0xafb30024, +0xafb20020, 0x809021, 0xa09821, 0xafb50028, +0xc0a821, 0xafbf0030, 0xafbe002c, 0xafb1001c, +0xafb00018, 0x8f900100, 0x276247e0, 0x16020003, +0xe0f021, 0x10000002, 0x27714000, 0x26110020, +0x8f820108, 0x16220008, 0x0, 0x8f430338, +0x1021, 0x24630001, 0xaf430338, 0x8f430338, +0x10000025, 0x0, 0x8f820104, 0x16220014, +0x2402024d, 0x3c040001, 0x248479e0, 0xafa20010, +0xafa00014, 0x8f860144, 0x3c070001, 0x24e779e8, +0xc002d3b, 0x3405dead, 0x8f82011c, 0x34420002, +0xaf82011c, 0x8f820220, 0x34420004, 0xaf820220, +0x8f820140, 0x3c030001, 0x431025, 0xaf820140, +0xae120000, 0xae130004, 0xae150008, 0xa61e000e, +0x8fa80048, 0xae080018, 0x8fa8004c, 0x26030016, +0xae08001c, 0xae030014, 0x8fa80050, 0x24020001, +0xae080010, 0xaf910100, 0x8fbf0030, 0x8fbe002c, +0x8fb50028, 0x8fb30024, 0x8fb20020, 0x8fb1001c, +0x8fb00018, 0x3e00008, 0x27bd0038, 0x3e00008, +0x0, 0x27bdffd8, 0x3c040001, 0x248479f0, +0x3c050001, 0xafbf0024, 0xafb20020, 0xafb1001c, +0xafb00018, 0x8f900104, 0x8f9100b0, 0x8f92011c, +0x34a52500, 0x8f820100, 0x2403021, 0x2203821, +0xafa20010, 0xc002d3b, 0xafb00014, 0x8e020008, +0xafa20010, 0x8e02000c, 0x3c040001, 0x248479fc, +0xafa20014, 0x8e060000, 0x8e070004, 0x3c050001, +0xc002d3b, 0x34a52510, 0x8e020018, 0xafa20010, +0x8e02001c, 0x3c040001, 0x24847a08, 0xafa20014, +0x8e060010, 0x8e070014, 0x3c050001, 0xc002d3b, +0x34a52520, 0x3c027f00, 0x2221024, 0x3c030800, +0x54430016, 0x3c030200, 0x8f82009c, 0x3042ffff, +0x14400012, 0x3c030200, 0x3c040001, 0x24847a14, +0x3c050002, 0x34a5f030, 0x3021, 0x3821, +0x36420002, 0xaf82011c, 0x36220001, 0xaf8200b0, +0xaf900104, 0xaf92011c, 0xafa00010, 0xc002d3b, +0xafa00014, 0x10000025, 0x0, 0x2c31024, +0x1040000e, 0x2231024, 0x1040000c, 0x36420002, +0xaf82011c, 0x36220001, 0xaf8200b0, 0xaf900104, +0xaf92011c, 0x8f420330, 0x24420001, 0xaf420330, +0x8f420330, 0x10000015, 0x0, 0x3c040001, +0x248479e0, 0x240202a9, 0xafa20010, 0xafa00014, +0x8f860144, 0x3c070001, 0x24e779e8, 0xc002d3b, +0x3405dead, 0x8f82011c, 0x34420002, 0xaf82011c, +0x8f820220, 0x34420004, 0xaf820220, 0x8f820140, +0x3c030001, 0x431025, 0xaf820140, 0x8fbf0024, +0x8fb20020, 0x8fb1001c, 0x8fb00018, 0x3e00008, +0x27bd0028, 0x27bdffd8, 0x3c040001, 0x24847a1c, +0x3c050001, 0xafbf0024, 0xafb20020, 0xafb1001c, +0xafb00018, 0x8f900124, 0x8f9100a0, 0x8f92011c, +0x34a52600, 0x8f820120, 0x2403021, 0x2203821, +0xafa20010, 0xc002d3b, 0xafb00014, 0x8e020008, +0xafa20010, 0x8e02000c, 0x3c040001, 0x24847a28, +0xafa20014, 0x8e060000, 0x8e070004, 0x3c050001, +0xc002d3b, 0x34a52610, 0x8e020018, 0xafa20010, +0x8e02001c, 0x3c040001, 0x24847a34, 0xafa20014, +0x8e060010, 0x8e070014, 0x3c050001, 0xc002d3b, +0x34a52620, 0x3c027f00, 0x2221024, 0x3c030800, +0x54430016, 0x3c030200, 0x8f8200ac, 0x3042ffff, +0x14400012, 0x3c030200, 0x3c040001, 0x24847a40, +0x3c050001, 0x34a5f030, 0x3021, 0x3821, 0x36420002, 0xaf82011c, 0x36220001, 0xaf8200a0, -0xaf900124, 0xaf92011c, 0x8f42032c, 0x24420001, -0xaf42032c, 0x10000015, 0x8f42032c, 0x3c040001, -0x24846558, 0x240202e2, 0xafa20010, 0xafa00014, -0x8f860144, 0x3c070001, 0x24e76560, 0xc002b37, +0xaf900124, 0xaf92011c, 0xafa00010, 0xc002d3b, +0xafa00014, 0x10000025, 0x0, 0x2c31024, +0x1040000e, 0x2231024, 0x1040000c, 0x36420002, +0xaf82011c, 0x36220001, 0xaf8200a0, 0xaf900124, +0xaf92011c, 0x8f42032c, 0x24420001, 0xaf42032c, +0x8f42032c, 0x10000015, 0x0, 0x3c040001, +0x248479e0, 0x240202e2, 0xafa20010, 0xafa00014, +0x8f860144, 0x3c070001, 0x24e779e8, 0xc002d3b, 0x3405dead, 0x8f82011c, 0x34420002, 0xaf82011c, 0x8f820220, 0x34420004, 0xaf820220, 0x8f820140, 0x3c030001, 0x431025, 0xaf820140, 0x8fbf0024, 0x8fb20020, 0x8fb1001c, 0x8fb00018, 0x3e00008, 0x27bd0028, 0x6021, 0x5021, 0x3021, 0x2821, 0x6821, 0x4821, 0x7821, -0x7021, 0x8f880124, 0x8f870104, 0x1580002e, -0x8f8b011c, 0x11a00014, 0x31620800, 0x8f820120, -0x10460029, 0x0, 0x3c040001, 0x8c846fa4, -0x8cc20000, 0x8cc30004, 0xac820000, 0xac830004, -0x8cc20008, 0xac820008, 0x94c2000e, 0xa482000e, -0x8cc20010, 0x240c0001, 0xac820010, 0x8cc20014, -0x10000012, 0x24c60020, 0x10400017, 0x0, -0x3c040001, 0x8c846fa4, 0x8d020000, 0x8d030004, -0xac820000, 0xac830004, 0x8d020008, 0xac820008, -0x9502000e, 0xa482000e, 0x8d020010, 0x25060020, -0xac820010, 0x8d020014, 0x240c0001, 0xc01821, -0xac820014, 0x27624fe0, 0x43102b, 0x54400001, -0x27634800, 0x603021, 0x1540002f, 0x31620100, -0x11200014, 0x31628000, 0x8f820100, 0x1045002a, -0x31620100, 0x3c040001, 0x8c846fa0, 0x8ca20000, -0x8ca30004, 0xac820000, 0xac830004, 0x8ca20008, -0xac820008, 0x94a2000e, 0xa482000e, 0x8ca20010, -0x240a0001, 0xac820010, 0x8ca20014, 0x10000012, -0x24a50020, 0x10400018, 0x31620100, 0x3c040001, -0x8c846fa0, 0x8ce20000, 0x8ce30004, 0xac820000, -0xac830004, 0x8ce20008, 0xac820008, 0x94e2000e, -0xa482000e, 0x8ce20010, 0x24e50020, 0xac820010, -0x8ce20014, 0x240a0001, 0xa01821, 0xac820014, -0x276247e0, 0x43102b, 0x54400001, 0x27634000, -0x602821, 0x31620100, 0x5440001d, 0x31621000, -0x11a00009, 0x31a20800, 0x10400004, 0x25020020, -0x8f8200a8, 0xa5e20000, 0x25020020, 0xaf820124, -0x8f880124, 0x6821, 0x11800011, 0x31621000, -0x3c040001, 0x8c846fa4, 0x8c820000, 0x8c830004, -0xaf820080, 0xaf830084, 0x8c820008, 0xaf8200a4, -0x9482000e, 0xaf8200ac, 0x8c820010, 0x6021, -0xaf8200a0, 0x8c8d0010, 0x8c8f0014, 0x31621000, -0x1440ff82, 0x0, 0x1120000f, 0x31220800, -0x10400004, 0x3c020002, 0x8f8200b8, 0xa5c20000, -0x3c020002, 0x1221024, 0x10400004, 0x24e20020, -0x8f8200b4, 0xaf8200d4, 0x24e20020, 0xaf820104, -0x8f870104, 0x4821, 0x1140ff70, 0x0, -0x3c040001, 0x8c846fa0, 0x8c820000, 0x8c830004, -0xaf820090, 0xaf830094, 0x8c820008, 0xaf8200b4, -0x9482000e, 0xaf82009c, 0x8c820010, 0x5021, -0xaf8200b0, 0x8c890010, 0x1000ff60, 0x8c8e0014, -0x3e00008, 0x0, 0x6021, 0x5821, -0x3021, 0x2821, 0x6821, 0x5021, -0x7821, 0x7021, 0x8f880124, 0x8f870104, -0x3c180100, 0x1580002e, 0x8f89011c, 0x11a00014, -0x31220800, 0x8f820120, 0x10460029, 0x0, -0x3c040001, 0x8c846fa4, 0x8cc20000, 0x8cc30004, -0xac820000, 0xac830004, 0x8cc20008, 0xac820008, -0x94c2000e, 0xa482000e, 0x8cc20010, 0x240c0001, -0xac820010, 0x8cc20014, 0x10000012, 0x24c60020, -0x10400017, 0x0, 0x3c040001, 0x8c846fa4, -0x8d020000, 0x8d030004, 0xac820000, 0xac830004, -0x8d020008, 0xac820008, 0x9502000e, 0xa482000e, -0x8d020010, 0x25060020, 0xac820010, 0x8d020014, -0x240c0001, 0xc01821, 0xac820014, 0x27624fe0, -0x43102b, 0x54400001, 0x27634800, 0x603021, -0x1560002f, 0x31220100, 0x11400014, 0x31228000, -0x8f820100, 0x1045002a, 0x31220100, 0x3c040001, -0x8c846fa0, 0x8ca20000, 0x8ca30004, 0xac820000, -0xac830004, 0x8ca20008, 0xac820008, 0x94a2000e, -0xa482000e, 0x8ca20010, 0x240b0001, 0xac820010, -0x8ca20014, 0x10000012, 0x24a50020, 0x10400018, -0x31220100, 0x3c040001, 0x8c846fa0, 0x8ce20000, -0x8ce30004, 0xac820000, 0xac830004, 0x8ce20008, -0xac820008, 0x94e2000e, 0xa482000e, 0x8ce20010, -0x24e50020, 0xac820010, 0x8ce20014, 0x240b0001, -0xa01821, 0xac820014, 0x276247e0, 0x43102b, -0x54400001, 0x27634000, 0x602821, 0x31220100, -0x5440001d, 0x31221000, 0x11a00009, 0x31a20800, -0x10400004, 0x25020020, 0x8f8200a8, 0xa5e20000, -0x25020020, 0xaf820124, 0x8f880124, 0x6821, -0x11800011, 0x31221000, 0x3c040001, 0x8c846fa4, -0x8c820000, 0x8c830004, 0xaf820080, 0xaf830084, -0x8c820008, 0xaf8200a4, 0x9482000e, 0xaf8200ac, -0x8c820010, 0x6021, 0xaf8200a0, 0x8c8d0010, -0x8c8f0014, 0x31221000, 0x14400022, 0x0, -0x1140000f, 0x31420800, 0x10400004, 0x3c020002, -0x8f8200b8, 0xa5c20000, 0x3c020002, 0x1421024, -0x10400004, 0x24e20020, 0x8f8200b4, 0xaf8200d4, -0x24e20020, 0xaf820104, 0x8f870104, 0x5021, -0x11600010, 0x0, 0x3c040001, 0x8c846fa0, -0x8c820000, 0x8c830004, 0xaf820090, 0xaf830094, -0x8c820008, 0xaf8200b4, 0x9482000e, 0xaf82009c, -0x8c820010, 0x5821, 0xaf8200b0, 0x8c8a0010, -0x8c8e0014, 0x8f820070, 0x3c031000, 0x431024, -0x1040ff5c, 0x0, 0x8f820054, 0x24420005, -0xaf820078, 0x8c040234, 0x10800016, 0x1821, -0x3c020001, 0x571021, 0x8c4240e8, 0x24420005, -0x3c010001, 0x370821, 0xac2240e8, 0x3c020001, -0x571021, 0x8c4240e8, 0x44102b, 0x14400009, -0x24020001, 0x3c030080, 0x3c010001, 0x370821, -0xac2040e8, 0x3c010001, 0x370821, 0x1000000c, -0xa02240f0, 0x3c020001, 0x571021, 0x904240f0, +0x7021, 0x8f880124, 0x8f870104, 0x8f8b011c, +0x1580002e, 0x0, 0x11a00014, 0x31620800, +0x8f820120, 0x10460029, 0x0, 0x3c040002, +0x8c848604, 0x8cc20000, 0x8cc30004, 0xac820000, +0xac830004, 0x8cc20008, 0xac820008, 0x94c2000e, +0xa482000e, 0x8cc20010, 0x240c0001, 0xac820010, +0x8cc20014, 0x10000012, 0x24c60020, 0x10400017, +0x0, 0x3c040002, 0x8c848604, 0x8d020000, +0x8d030004, 0xac820000, 0xac830004, 0x8d020008, +0xac820008, 0x9502000e, 0xa482000e, 0x8d020010, +0x25060020, 0xac820010, 0x8d020014, 0x240c0001, +0xc01821, 0xac820014, 0x27624fe0, 0x43102b, +0x54400001, 0x27634800, 0x603021, 0x1540002f, +0x31620100, 0x11200014, 0x31628000, 0x8f820100, +0x1045002a, 0x31620100, 0x3c040002, 0x8c848600, +0x8ca20000, 0x8ca30004, 0xac820000, 0xac830004, +0x8ca20008, 0xac820008, 0x94a2000e, 0xa482000e, +0x8ca20010, 0x240a0001, 0xac820010, 0x8ca20014, +0x10000012, 0x24a50020, 0x10400018, 0x31620100, +0x3c040002, 0x8c848600, 0x8ce20000, 0x8ce30004, +0xac820000, 0xac830004, 0x8ce20008, 0xac820008, +0x94e2000e, 0xa482000e, 0x8ce20010, 0x24e50020, +0xac820010, 0x8ce20014, 0x240a0001, 0xa01821, +0xac820014, 0x276247e0, 0x43102b, 0x54400001, +0x27634000, 0x602821, 0x31620100, 0x5440001d, +0x31621000, 0x11a00009, 0x31a20800, 0x10400004, +0x25020020, 0x8f8200a8, 0xa5e20000, 0x25020020, +0xaf820124, 0x8f880124, 0x6821, 0x11800011, +0x31621000, 0x3c040002, 0x8c848604, 0x8c820000, +0x8c830004, 0xaf820080, 0xaf830084, 0x8c820008, +0xaf8200a4, 0x9482000e, 0xaf8200ac, 0x8c820010, +0x6021, 0xaf8200a0, 0x8c8d0010, 0x8c8f0014, +0x31621000, 0x1440ff81, 0x0, 0x1120000f, +0x31220800, 0x10400004, 0x3c020002, 0x8f8200b8, +0xa5c20000, 0x3c020002, 0x1221024, 0x10400004, +0x24e20020, 0x8f8200b4, 0xaf8200d4, 0x24e20020, +0xaf820104, 0x8f870104, 0x4821, 0x1140ff6f, +0x0, 0x3c040002, 0x8c848600, 0x8c820000, +0x8c830004, 0xaf820090, 0xaf830094, 0x8c820008, +0xaf8200b4, 0x9482000e, 0xaf82009c, 0x8c820010, +0x5021, 0xaf8200b0, 0x8c890010, 0x8c8e0014, +0x1000ff5e, 0x0, 0x3e00008, 0x0, +0x6021, 0x5821, 0x3021, 0x2821, +0x6821, 0x5021, 0x7821, 0x7021, +0x8f880124, 0x8f870104, 0x3c180100, 0x8f89011c, +0x1580002e, 0x0, 0x11a00014, 0x31220800, +0x8f820120, 0x10460029, 0x0, 0x3c040002, +0x8c848604, 0x8cc20000, 0x8cc30004, 0xac820000, +0xac830004, 0x8cc20008, 0xac820008, 0x94c2000e, +0xa482000e, 0x8cc20010, 0x240c0001, 0xac820010, +0x8cc20014, 0x10000012, 0x24c60020, 0x10400017, +0x0, 0x3c040002, 0x8c848604, 0x8d020000, +0x8d030004, 0xac820000, 0xac830004, 0x8d020008, +0xac820008, 0x9502000e, 0xa482000e, 0x8d020010, +0x25060020, 0xac820010, 0x8d020014, 0x240c0001, +0xc01821, 0xac820014, 0x27624fe0, 0x43102b, +0x54400001, 0x27634800, 0x603021, 0x1560002f, +0x31220100, 0x11400014, 0x31228000, 0x8f820100, +0x1045002a, 0x31220100, 0x3c040002, 0x8c848600, +0x8ca20000, 0x8ca30004, 0xac820000, 0xac830004, +0x8ca20008, 0xac820008, 0x94a2000e, 0xa482000e, +0x8ca20010, 0x240b0001, 0xac820010, 0x8ca20014, +0x10000012, 0x24a50020, 0x10400018, 0x31220100, +0x3c040002, 0x8c848600, 0x8ce20000, 0x8ce30004, +0xac820000, 0xac830004, 0x8ce20008, 0xac820008, +0x94e2000e, 0xa482000e, 0x8ce20010, 0x24e50020, +0xac820010, 0x8ce20014, 0x240b0001, 0xa01821, +0xac820014, 0x276247e0, 0x43102b, 0x54400001, +0x27634000, 0x602821, 0x31220100, 0x5440001d, +0x31221000, 0x11a00009, 0x31a20800, 0x10400004, +0x25020020, 0x8f8200a8, 0xa5e20000, 0x25020020, +0xaf820124, 0x8f880124, 0x6821, 0x11800011, +0x31221000, 0x3c040002, 0x8c848604, 0x8c820000, +0x8c830004, 0xaf820080, 0xaf830084, 0x8c820008, +0xaf8200a4, 0x9482000e, 0xaf8200ac, 0x8c820010, +0x6021, 0xaf8200a0, 0x8c8d0010, 0x8c8f0014, +0x31221000, 0x14400022, 0x0, 0x1140000f, +0x31420800, 0x10400004, 0x3c020002, 0x8f8200b8, +0xa5c20000, 0x3c020002, 0x1421024, 0x10400004, +0x24e20020, 0x8f8200b4, 0xaf8200d4, 0x24e20020, +0xaf820104, 0x8f870104, 0x5021, 0x11600010, +0x0, 0x3c040002, 0x8c848600, 0x8c820000, +0x8c830004, 0xaf820090, 0xaf830094, 0x8c820008, +0xaf8200b4, 0x9482000e, 0xaf82009c, 0x8c820010, +0x5821, 0xaf8200b0, 0x8c8a0010, 0x8c8e0014, +0x8f820070, 0x3c031000, 0x431024, 0x1040ff5b, +0x0, 0x8f820054, 0x24420005, 0xaf820078, +0x8c040234, 0x10800017, 0x1821, 0x3c020001, +0x571021, 0x8c4240e8, 0x24420005, 0x3c010001, +0x370821, 0xac2240e8, 0x3c020001, 0x571021, +0x8c4240e8, 0x44102b, 0x1440000a, 0x24020001, +0x3c030080, 0x3c010001, 0x370821, 0xac2040e8, +0x3c010001, 0x370821, 0xa02240f0, 0x1000000c, +0x0, 0x3c020001, 0x571021, 0x904240f0, 0x14400006, 0x3c020080, 0x3c020001, 0x571021, 0x904240f1, 0x10400002, 0x3c020080, 0x621825, 0x8c040230, 0x10800013, 0x0, 0x3c020001, @@ -1752,48 +1875,48 @@ 0x8c4240ec, 0x44102b, 0x14400006, 0x0, 0x3c010001, 0x370821, 0xac2040ec, 0x10000006, 0x781825, 0x3c020001, 0x571021, 0x904240f2, -0x54400001, 0x781825, 0x1060ff1a, 0x0, +0x54400001, 0x781825, 0x1060ff18, 0x0, 0x8f420000, 0x10400007, 0x0, 0xaf80004c, 0x8f82004c, 0x1040fffd, 0x0, 0x10000005, 0x0, 0xaf800048, 0x8f820048, 0x1040fffd, 0x0, 0x8f820060, 0x431025, 0xaf820060, -0x8f420000, 0x10400003, 0x0, 0x1000ff05, -0xaf80004c, 0x1000ff03, 0xaf800048, 0x3e00008, -0x0, 0x0, 0x0, 0x3c020001, -0x8c426de8, 0x27bdffe8, 0xafbf0014, 0x14400012, -0xafb00010, 0x3c100001, 0x26107050, 0x2002021, -0xc002ba4, 0x24052000, 0x26021fe0, 0x3c010001, -0xac226fac, 0x3c010001, 0xac226fa8, 0xac020250, +0x8f420000, 0x10400004, 0x0, 0xaf80004c, +0x1000ff02, 0x0, 0xaf800048, 0x1000feff, +0x0, 0x3e00008, 0x0, 0x3c020002, +0x8c428468, 0x27bdffe8, 0xafbf0014, 0x14400012, +0xafb00010, 0x3c100002, 0x261086b0, 0x2002021, +0xc002da8, 0x24052000, 0x26021fe0, 0x3c010002, +0xac22860c, 0x3c010002, 0xac228608, 0xac020250, 0x24022000, 0xac100254, 0xac020258, 0x24020001, -0x3c010001, 0xac226de8, 0x8fbf0014, 0x8fb00010, -0x3e00008, 0x27bd0018, 0x3c090001, 0x8d296fac, +0x3c010002, 0xac228468, 0x8fbf0014, 0x8fb00010, +0x3e00008, 0x27bd0018, 0x3c090002, 0x8d29860c, 0x8c820000, 0x8fa30010, 0x8fa80014, 0xad220000, 0x8c820004, 0xad250008, 0xad220004, 0x8f820054, 0xad260010, 0xad270014, 0xad230018, 0xad28001c, -0xad22000c, 0x2529ffe0, 0x3c020001, 0x24427050, -0x122102b, 0x10400003, 0x0, 0x3c090001, -0x8d296fa8, 0x3c020001, 0x8c426dd0, 0xad220000, -0x3c020001, 0x8c426dd0, 0x3c010001, 0xac296fac, -0xad220004, 0x3e00008, 0xac090250, 0x27bdffd0, -0xafb00010, 0x3c100001, 0x8e106fac, 0x3c020001, -0x8c426dd0, 0xafb10014, 0x808821, 0xafbe0024, -0x8fbe0040, 0x8fa40048, 0xafb20018, 0xa09021, -0xafbf0028, 0xafb50020, 0xafb3001c, 0xae020000, -0x3c020001, 0x8c426dd0, 0xc09821, 0xe0a821, -0x10800006, 0xae020004, 0x26050008, 0xc002baf, -0x24060018, 0x10000005, 0x2610ffe0, 0x26040008, -0xc002ba4, 0x24050018, 0x2610ffe0, 0x3c030001, -0x24637050, 0x203102b, 0x10400003, 0x0, -0x3c100001, 0x8e106fa8, 0x8e220000, 0xae020000, -0x8e220004, 0xae120008, 0xae020004, 0x8f820054, -0xae130010, 0xae150014, 0xae1e0018, 0x8fa80044, -0xae08001c, 0xae02000c, 0x2610ffe0, 0x203102b, -0x10400003, 0x0, 0x3c100001, 0x8e106fa8, -0x3c020001, 0x8c426dd0, 0xae020000, 0x3c020001, -0x8c426dd0, 0x3c010001, 0xac306fac, 0xae020004, -0xac100250, 0x8fbf0028, 0x8fbe0024, 0x8fb50020, -0x8fb3001c, 0x8fb20018, 0x8fb10014, 0x8fb00010, -0x3e00008, 0x27bd0030, 0x0, 0x851821, +0xad22000c, 0x2529ffe0, 0x3c020002, 0x244286b0, +0x122102b, 0x10400003, 0x0, 0x3c090002, +0x8d298608, 0x3c020002, 0x8c42845c, 0xad220000, +0x3c020002, 0x8c42845c, 0x3c010002, 0xac29860c, +0xad220004, 0xac090250, 0x3e00008, 0x0, +0x27bdffd0, 0xafb00010, 0x3c100002, 0x8e10860c, +0x3c020002, 0x8c42845c, 0xafb10014, 0x808821, +0xafbe0024, 0x8fbe0040, 0x8fa40048, 0xafb20018, +0xa09021, 0xafbf0028, 0xafb50020, 0xafb3001c, +0xae020000, 0x3c020002, 0x8c42845c, 0xc09821, +0xe0a821, 0x10800006, 0xae020004, 0x26050008, +0xc002db3, 0x24060018, 0x10000005, 0x2610ffe0, +0x26040008, 0xc002da8, 0x24050018, 0x2610ffe0, +0x3c030002, 0x246386b0, 0x203102b, 0x10400003, +0x0, 0x3c100002, 0x8e108608, 0x8e220000, +0xae020000, 0x8e220004, 0xae120008, 0xae020004, +0x8f820054, 0xae130010, 0xae150014, 0xae1e0018, +0x8fa80044, 0xae08001c, 0xae02000c, 0x2610ffe0, +0x203102b, 0x10400003, 0x0, 0x3c100002, +0x8e108608, 0x3c020002, 0x8c42845c, 0xae020000, +0x3c020002, 0x8c42845c, 0x3c010002, 0xac30860c, +0xae020004, 0xac100250, 0x8fbf0028, 0x8fbe0024, +0x8fb50020, 0x8fb3001c, 0x8fb20018, 0x8fb10014, +0x8fb00010, 0x3e00008, 0x27bd0030, 0x851821, 0x83102b, 0x10400006, 0x0, 0xac800000, 0x24840004, 0x83102b, 0x5440fffd, 0xac800000, 0x3e00008, 0x0, 0xa61821, 0xa3102b, @@ -1805,89 +1928,101 @@ 0x3e00008, 0x0, 0x63080, 0x861821, 0x83102b, 0x10400006, 0x0, 0xac850000, 0x24840004, 0x83102b, 0x5440fffd, 0xac850000, -0x3e00008, 0x0, 0x0, 0x26e50028, -0xa03021, 0x274301c0, 0x8f4d0358, 0x8f47035c, -0x8f480360, 0x8f490364, 0x8f4a0368, 0x8f4b0204, -0x8f4c0200, 0x24640400, 0x64102b, 0x10400008, -0x3c0208ff, 0x8cc20000, 0xac620000, 0x24630004, -0x64102b, 0x1440fffb, 0x24c60004, 0x3c0208ff, -0x3442ffff, 0x3c03c0ff, 0xaf4d0358, 0xaf47035c, -0xaf480360, 0xaf490364, 0xaf4a0368, 0xaf4b0204, -0xaf4c0200, 0x8f840220, 0x3463ffff, 0x8f860200, -0x821024, 0x34420004, 0xc31824, 0x34630004, -0xaf820220, 0xaf830200, 0x8ca20214, 0xac020084, -0x8ca20218, 0xac020088, 0x8ca2021c, 0xac02008c, -0x8ca20220, 0xac020090, 0x8ca20224, 0xac020094, -0x8ca20228, 0xac020098, 0x8ca2022c, 0xac02009c, -0x8ca20230, 0xac0200a0, 0x8ca20234, 0xac0200a4, -0x8ca20238, 0xac0200a8, 0x8ca2023c, 0xac0200ac, -0x8ca20240, 0xac0200b0, 0x8ca20244, 0xac0200b4, -0x8ca20248, 0xac0200b8, 0x8ca2024c, 0xac0200bc, -0x8ca2001c, 0xac020080, 0x8ca20018, 0xac0200c0, -0x8ca20020, 0xac0200cc, 0x8ca20024, 0xac0200d0, -0x8ca201d0, 0xac0200e0, 0x8ca201d4, 0xac0200e4, -0x8ca201d8, 0xac0200e8, 0x8ca201dc, 0xac0200ec, -0x8ca201e0, 0xac0200f0, 0x8ca20098, 0x8ca3009c, -0xac0300fc, 0x8ca200a8, 0x8ca300ac, 0xac0300f4, -0x8ca200a0, 0x8ca300a4, 0x30840004, 0xac0300f8, -0x14800007, 0x30c20004, 0x8f820220, 0x3c0308ff, -0x3463fffb, 0x431024, 0xaf820220, 0x30c20004, -0x14400006, 0x0, 0x8f820200, 0x3c03c0ff, -0x3463fffb, 0x431024, 0xaf820200, 0x8f4202dc, -0xa34005c5, 0x24420001, 0xaf4202dc, 0x3e00008, -0x8f4202dc, 0x27bdffd8, 0xafbf0024, 0xafb00020, -0x8f430024, 0x8f420020, 0x10620038, 0x0, -0x8f430020, 0x8f420024, 0x622023, 0x4810003, -0x0, 0x8f420040, 0x822021, 0x8f430030, -0x8f420024, 0x43102b, 0x14400005, 0x0, -0x8f430040, 0x8f420024, 0x10000005, 0x621023, -0x8f420030, 0x8f430024, 0x431023, 0x2442ffff, -0x406021, 0x8c102a, 0x54400001, 0x806021, -0x8f4a0024, 0x8f490040, 0x8f480024, 0x8f440180, -0x8f450184, 0x8f460024, 0x8f4b001c, 0x24070001, -0xafa70010, 0x84100, 0x1001821, 0x14c5021, -0x2529ffff, 0x1498024, 0xafb00014, 0x8f470014, -0x1021, 0x63100, 0xafa70018, 0xa32821, -0xa3382b, 0x822021, 0x872021, 0x8f420108, -0x1663021, 0x40f809, 0xc3900, 0x54400001, -0xaf500024, 0x8f430024, 0x8f420020, 0x14620018, -0x0, 0x8f420000, 0x10400007, 0x0, -0xaf80004c, 0x8f82004c, 0x1040fffd, 0x0, -0x10000005, 0x0, 0xaf800048, 0x8f820048, -0x1040fffd, 0x0, 0x8f820060, 0x2403ffef, -0x431024, 0xaf820060, 0x8f420000, 0x10400003, -0x0, 0x10000002, 0xaf80004c, 0xaf800048, -0x8fbf0024, 0x8fb00020, 0x3e00008, 0x27bd0028, -0x3e00008, 0x0, 0x27bdffc0, 0x32c20020, -0xafbf0038, 0xafb30034, 0xafb20030, 0xafb1002c, -0x10400004, 0xafb00028, 0x8f530028, 0x10000002, -0x0, 0x8f530020, 0x8f420030, 0x105300eb, -0x21100, 0x8f43001c, 0x628021, 0x8e040000, -0x8e050004, 0x96120008, 0x8f420090, 0x9611000a, -0x3246ffff, 0x46102a, 0x10400017, 0x0, -0x8f8200d8, 0x8f430098, 0x431023, 0x2442dcbe, -0xaf420090, 0x8f420090, 0x2842dcbf, 0x10400005, -0x0, 0x8f420090, 0x8f430144, 0x431021, -0xaf420090, 0x8f420090, 0x46102a, 0x10400006, -0x0, 0x8f420348, 0x24420001, 0xaf420348, -0x100000e1, 0x8f420348, 0x8f8200fc, 0x14400006, -0x0, 0x8f420344, 0x24420001, 0xaf420344, -0x100000d9, 0x8f420344, 0x934205c2, 0x1040000b, -0x32c20008, 0x10400008, 0x32220200, 0x10400006, -0x3c034000, 0x9602000e, 0xaf4300ac, 0x21400, -0x10000002, 0xaf4200b0, 0xaf4000ac, 0x32220004, -0x1040007f, 0x32220800, 0x10400003, 0x3247ffff, -0x10000002, 0x24020020, 0x24020004, 0xafa20010, -0x8f420030, 0xafa20014, 0x8f420010, 0x3c030002, -0x431025, 0xafa20018, 0x8f460098, 0x8f420108, -0x40f809, 0x0, 0x104000b7, 0x0, -0x8f42009c, 0x8f430094, 0x2421021, 0xaf42009c, -0xae03000c, 0x8f4200ac, 0x10400008, 0x3c034000, -0x8f420094, 0x431025, 0xafa20020, 0x8f42009c, -0x8f4300b0, 0x10000004, 0x431025, 0x8f420094, -0xafa20020, 0x8f42009c, 0xafa20024, 0x8f8200fc, -0x8fa30020, 0x8fa40024, 0xac430000, 0xac440004, -0x24420008, 0xaf8200f0, 0x8f42009c, 0x8f440270, +0x3e00008, 0x0, 0x26e50028, 0xa03021, +0x274301c0, 0x8f4d0358, 0x8f47035c, 0x8f480360, +0x8f490364, 0x8f4a0368, 0x8f4b0204, 0x8f4c0200, +0x24640400, 0x64102b, 0x10400008, 0x3c0208ff, +0x8cc20000, 0xac620000, 0x24630004, 0x64102b, +0x1440fffb, 0x24c60004, 0x3c0208ff, 0x3442ffff, +0x3c03c0ff, 0xaf4d0358, 0xaf47035c, 0xaf480360, +0xaf490364, 0xaf4a0368, 0xaf4b0204, 0xaf4c0200, +0x8f840220, 0x3463ffff, 0x8f860200, 0x821024, +0x34420004, 0xc31824, 0x34630004, 0xaf820220, +0xaf830200, 0x8ca20214, 0xac020084, 0x8ca20218, +0xac020088, 0x8ca2021c, 0xac02008c, 0x8ca20220, +0xac020090, 0x8ca20224, 0xac020094, 0x8ca20228, +0xac020098, 0x8ca2022c, 0xac02009c, 0x8ca20230, +0xac0200a0, 0x8ca20234, 0xac0200a4, 0x8ca20238, +0xac0200a8, 0x8ca2023c, 0xac0200ac, 0x8ca20240, +0xac0200b0, 0x8ca20244, 0xac0200b4, 0x8ca20248, +0xac0200b8, 0x8ca2024c, 0xac0200bc, 0x8ca2001c, +0xac020080, 0x8ca20018, 0xac0200c0, 0x8ca20020, +0xac0200cc, 0x8ca20024, 0xac0200d0, 0x8ca201d0, +0xac0200e0, 0x8ca201d4, 0xac0200e4, 0x8ca201d8, +0xac0200e8, 0x8ca201dc, 0xac0200ec, 0x8ca201e0, +0xac0200f0, 0x8ca20098, 0x8ca3009c, 0xac0300fc, +0x8ca200a8, 0x8ca300ac, 0xac0300f4, 0x8ca200a0, +0x8ca300a4, 0x30840004, 0xac0300f8, 0x14800007, +0x30c20004, 0x8f820220, 0x3c0308ff, 0x3463fffb, +0x431024, 0xaf820220, 0x30c20004, 0x14400006, +0x0, 0x8f820200, 0x3c03c0ff, 0x3463fffb, +0x431024, 0xaf820200, 0x8f4202dc, 0xa34005c5, +0x24420001, 0xaf4202dc, 0x8f4202dc, 0x3e00008, +0x0, 0x27bdffd0, 0xafbf0028, 0xafb10024, +0xafb00020, 0x8f430024, 0x8f420020, 0x1062004e, +0x0, 0x8f430020, 0x8f420024, 0x628823, +0x6210003, 0x0, 0x8f420040, 0x2228821, +0x8f430030, 0x8f420024, 0x43102b, 0x14400005, +0x0, 0x8f430040, 0x8f420024, 0x10000005, +0x628023, 0x8f420030, 0x8f430024, 0x431023, +0x2450ffff, 0x16000016, 0x2006821, 0x3c040001, +0x24847cac, 0x240202aa, 0xafa20010, 0xafa00014, +0x8f860144, 0x3c070001, 0x24e77cbc, 0xc002d3b, +0x3405dead, 0x8f82011c, 0x34420002, 0xaf82011c, +0x8f820220, 0x34420004, 0xaf820220, 0x8f820140, +0x3c030001, 0x431025, 0xaf820140, 0x2006821, +0x22d102a, 0x54400001, 0x2206821, 0x8f4b0024, +0x8f4a0040, 0x8f490024, 0x8f440180, 0x8f450184, +0x8f460024, 0x8f4c001c, 0xd3900, 0x24080001, +0xafa80010, 0x94900, 0x1201821, 0x16d5821, +0x254affff, 0x16a8024, 0xafb00014, 0x8f480014, +0x1021, 0xa32821, 0xa3482b, 0x822021, +0x892021, 0xafa80018, 0x8f420108, 0x63100, +0x40f809, 0x1863021, 0x54400001, 0xaf500024, +0x8f430024, 0x8f420020, 0x14620019, 0x0, +0x8f420000, 0x10400007, 0x0, 0xaf80004c, +0x8f82004c, 0x1040fffd, 0x0, 0x10000005, +0x0, 0xaf800048, 0x8f820048, 0x1040fffd, +0x0, 0x8f820060, 0x2403ffef, 0x431024, +0xaf820060, 0x8f420000, 0x10400004, 0x0, +0xaf80004c, 0x10000002, 0x0, 0xaf800048, +0x8fbf0028, 0x8fb10024, 0x8fb00020, 0x3e00008, +0x27bd0030, 0x3e00008, 0x0, 0x27bdffc0, +0x32c20020, 0xafbf0038, 0xafb30034, 0xafb20030, +0xafb1002c, 0x10400004, 0xafb00028, 0x8f530028, +0x10000002, 0x0, 0x8f530020, 0x8f420030, +0x10530102, 0x21100, 0x8f43001c, 0x628021, +0x8e040000, 0x8e050004, 0x96120008, 0x8f420090, +0x9611000a, 0x3246ffff, 0x46102a, 0x10400018, +0x0, 0x8f8200d8, 0x8f430098, 0x431023, +0x2442dcbe, 0xaf420090, 0x8f420090, 0x2842dcbf, +0x10400005, 0x0, 0x8f420090, 0x8f430144, +0x431021, 0xaf420090, 0x8f420090, 0x46102a, +0x10400007, 0x0, 0x8f420348, 0x24420001, +0xaf420348, 0x8f420348, 0x100000f8, 0x0, +0x8f8200fc, 0x14400007, 0x0, 0x8f420344, +0x24420001, 0xaf420344, 0x8f420344, 0x100000ef, +0x0, 0x934205c2, 0x1040000b, 0x32c20008, +0x10400008, 0x32220200, 0x10400006, 0x3c034000, +0x9602000e, 0xaf4300ac, 0x21400, 0x10000002, +0xaf4200b0, 0xaf4000ac, 0x32220004, 0x10400094, +0x32220800, 0x10400003, 0x3247ffff, 0x10000002, +0x24020020, 0x24020004, 0xafa20010, 0x8f420030, +0xafa20014, 0x8f420010, 0x3c030002, 0x431025, +0xafa20018, 0x8f460098, 0x8f420108, 0x40f809, +0x0, 0x104000cd, 0x0, 0x8f42009c, +0x8f430094, 0x2421021, 0xaf42009c, 0xae03000c, +0x8f4200ac, 0x10400008, 0x3c034000, 0x8f420094, +0x431025, 0xafa20020, 0x8f42009c, 0x8f4300b0, +0x10000004, 0x431025, 0x8f420094, 0xafa20020, +0x8f42009c, 0xafa20024, 0x8f9000fc, 0x16000014, +0x240200e1, 0x3c040001, 0x24847cac, 0xafa20010, +0xafa00014, 0x8f860144, 0x3c070001, 0x24e77cb4, +0xc002d3b, 0x3405dead, 0x8f82011c, 0x34420002, +0xaf82011c, 0x8f820220, 0x34420004, 0xaf820220, +0x8f820140, 0x3c030001, 0x431025, 0xaf820140, +0x8fa20020, 0x8fa30024, 0xae020000, 0xae030004, +0x26020008, 0xaf8200f0, 0x8f42009c, 0x8f440270, 0x8f450274, 0x401821, 0x1021, 0xa32821, 0xa3302b, 0x822021, 0x862021, 0x32230060, 0x24020040, 0xaf440270, 0xaf450274, 0x10620017, @@ -1911,7 +2046,7 @@ 0x3247ffff, 0x50e00022, 0x32c20020, 0x14400002, 0x24020010, 0x24020002, 0xafa20010, 0x8f420030, 0xafa20014, 0x8f420010, 0xafa20018, 0x8f460098, -0x8f420108, 0x40f809, 0x0, 0x1040003a, +0x8f420108, 0x40f809, 0x0, 0x1040003b, 0x3245ffff, 0x8f420098, 0x8f430090, 0x8f46013c, 0x451021, 0xaf420098, 0x8f42009c, 0x8f440098, 0xa34005c2, 0x651823, 0xaf430090, 0x451021, @@ -1920,347 +2055,406 @@ 0x10400005, 0x0, 0x8f420358, 0x2442ffff, 0xaf420358, 0x8f420358, 0x8f420030, 0x8f430040, 0x24420001, 0x2463ffff, 0x431024, 0xaf420030, -0x8f420030, 0x14530018, 0x0, 0x8f420000, +0x8f420030, 0x14530019, 0x0, 0x8f420000, 0x10400007, 0x0, 0xaf80004c, 0x8f82004c, 0x1040fffd, 0x0, 0x10000005, 0x0, 0xaf800048, 0x8f820048, 0x1040fffd, 0x0, 0x8f820060, 0x2403fff7, 0x431024, 0xaf820060, -0x8f420000, 0x10400003, 0x0, 0x10000002, -0xaf80004c, 0xaf800048, 0x8fbf0038, 0x8fb30034, -0x8fb20030, 0x8fb1002c, 0x8fb00028, 0x3e00008, -0x27bd0040, 0x3e00008, 0x0, 0x27bdffd0, -0x32c20020, 0xafbf002c, 0xafb20028, 0xafb10024, -0x10400004, 0xafb00020, 0x8f520028, 0x10000002, -0x0, 0x8f520020, 0x8f420030, 0x105200b5, -0x21100, 0x8f43001c, 0x628021, 0x8e040000, -0x8e050004, 0x96110008, 0x8f420090, 0x9607000a, -0x3226ffff, 0x46102a, 0x10400017, 0x0, -0x8f8200d8, 0x8f430098, 0x431023, 0x2442dc46, -0xaf420090, 0x8f420090, 0x2842dc47, 0x10400005, -0x0, 0x8f420090, 0x8f430144, 0x431021, -0xaf420090, 0x8f420090, 0x46102a, 0x10400006, -0x0, 0x8f420348, 0x24420001, 0xaf420348, -0x100000ab, 0x8f420348, 0x8f8600fc, 0x10c0000c, -0x0, 0x8f8200f4, 0x2403fff8, 0x431024, -0x461023, 0x218c3, 0x58600001, 0x24630100, -0x8f42008c, 0x43102b, 0x14400006, 0x712c2, -0x8f420344, 0x24420001, 0xaf420344, 0x10000098, -0x8f420344, 0x934305c2, 0x1060000f, 0x30460001, -0x8f420010, 0x34480400, 0x32c20008, 0x10400008, -0x30e20200, 0x10400006, 0x3c034000, 0x9602000e, -0xaf4300ac, 0x21400, 0x10000004, 0xaf4200b0, -0x10000002, 0xaf4000ac, 0x8f480010, 0x30e20004, -0x10400045, 0x3227ffff, 0x8f4900ac, 0x11200005, -0x30c200ff, 0x14400006, 0x24020040, 0x10000004, -0x24020008, 0x14400002, 0x24020020, 0x24020004, -0xafa20010, 0x8f430030, 0x11200004, 0xafa30014, -0x8f4200b0, 0x621025, 0xafa20014, 0x3c020002, -0x1021025, 0xafa20018, 0x8f460098, 0x8f420108, -0x40f809, 0x0, 0x10400069, 0x3224ffff, -0x8f42008c, 0x8f430094, 0x24420001, 0xaf42008c, -0x24020001, 0xae03000c, 0xa34205c2, 0x8f420098, -0x2406fff8, 0x8f45013c, 0x441021, 0x24420007, -0x461024, 0x24840007, 0xaf420094, 0x8f420090, -0x8f430094, 0x862024, 0x441023, 0x65182b, -0x14600005, 0xaf420090, 0x8f420094, 0x8f430144, -0x431023, 0xaf420094, 0x8f430094, 0x8f420140, -0x43102b, 0x10400009, 0x0, 0x8f43013c, -0x8f440094, 0x8f420090, 0x8f450138, 0x641823, -0x431023, 0xaf420090, 0xaf450094, 0x8f420094, -0x1000001f, 0xaf420098, 0x10e0001d, 0x30c200ff, -0x14400002, 0x24020010, 0x24020002, 0xafa20010, -0x8f420030, 0xafa80018, 0xafa20014, 0x8f460098, -0x8f420108, 0x40f809, 0x0, 0x10400030, -0x3225ffff, 0x8f420098, 0x8f44013c, 0x451021, -0xaf420098, 0x8f420090, 0x8f430098, 0xa34005c2, -0x451023, 0x64182b, 0x14600005, 0xaf420090, -0x8f420098, 0x8f430144, 0x431023, 0xaf420098, -0x8f420030, 0x8f430040, 0x24420001, 0x2463ffff, -0x431024, 0xaf420030, 0x8f420030, 0x14520018, -0x0, 0x8f420000, 0x10400007, 0x0, -0xaf80004c, 0x8f82004c, 0x1040fffd, 0x0, -0x10000005, 0x0, 0xaf800048, 0x8f820048, -0x1040fffd, 0x0, 0x8f820060, 0x2403fff7, -0x431024, 0xaf820060, 0x8f420000, 0x10400003, -0x0, 0x10000002, 0xaf80004c, 0xaf800048, +0x8f420000, 0x10400004, 0x0, 0xaf80004c, +0x10000002, 0x0, 0xaf800048, 0x8fbf0038, +0x8fb30034, 0x8fb20030, 0x8fb1002c, 0x8fb00028, +0x3e00008, 0x27bd0040, 0x3e00008, 0x0, +0x27bdffd0, 0x32c20020, 0xafbf002c, 0xafb20028, +0xafb10024, 0x10400004, 0xafb00020, 0x8f520028, +0x10000002, 0x0, 0x8f520020, 0x8f420030, +0x105200b7, 0x21100, 0x8f43001c, 0x628021, +0x8e040000, 0x8e050004, 0x96110008, 0x8f420090, +0x9607000a, 0x3226ffff, 0x46102a, 0x10400018, +0x0, 0x8f8200d8, 0x8f430098, 0x431023, +0x2442dc46, 0xaf420090, 0x8f420090, 0x2842dc47, +0x10400005, 0x0, 0x8f420090, 0x8f430144, +0x431021, 0xaf420090, 0x8f420090, 0x46102a, +0x10400007, 0x0, 0x8f420348, 0x24420001, +0xaf420348, 0x8f420348, 0x100000ad, 0x0, +0x8f8600fc, 0x10c0000c, 0x0, 0x8f8200f4, +0x2403fff8, 0x431024, 0x461023, 0x218c3, +0x58600001, 0x24630100, 0x8f42008c, 0x43102b, +0x14400007, 0x712c2, 0x8f420344, 0x24420001, +0xaf420344, 0x8f420344, 0x10000099, 0x0, +0x934305c2, 0x1060000f, 0x30460001, 0x8f420010, +0x34480400, 0x32c20008, 0x10400008, 0x30e20200, +0x10400006, 0x3c034000, 0x9602000e, 0xaf4300ac, +0x21400, 0x10000004, 0xaf4200b0, 0x10000002, +0xaf4000ac, 0x8f480010, 0x30e20004, 0x10400045, +0x3227ffff, 0x8f4900ac, 0x11200005, 0x30c200ff, +0x14400006, 0x24020040, 0x10000004, 0x24020008, +0x14400002, 0x24020020, 0x24020004, 0xafa20010, +0x8f430030, 0x11200004, 0xafa30014, 0x8f4200b0, +0x621025, 0xafa20014, 0x3c020002, 0x1021025, +0xafa20018, 0x8f460098, 0x8f420108, 0x40f809, +0x0, 0x1040006a, 0x3224ffff, 0x8f42008c, +0x8f430094, 0x24420001, 0xaf42008c, 0x24020001, +0xae03000c, 0xa34205c2, 0x8f420098, 0x2406fff8, +0x8f45013c, 0x441021, 0x24420007, 0x461024, +0x24840007, 0xaf420094, 0x8f420090, 0x8f430094, +0x862024, 0x441023, 0x65182b, 0x14600005, +0xaf420090, 0x8f420094, 0x8f430144, 0x431023, +0xaf420094, 0x8f430094, 0x8f420140, 0x43102b, +0x10400009, 0x0, 0x8f43013c, 0x8f440094, +0x8f420090, 0x8f450138, 0x641823, 0x431023, +0xaf420090, 0xaf450094, 0x8f420094, 0x1000001f, +0xaf420098, 0x10e0001d, 0x30c200ff, 0x14400002, +0x24020010, 0x24020002, 0xafa20010, 0x8f420030, +0xafa80018, 0xafa20014, 0x8f460098, 0x8f420108, +0x40f809, 0x0, 0x10400031, 0x3225ffff, +0x8f420098, 0x8f44013c, 0x451021, 0xaf420098, +0x8f420090, 0x8f430098, 0xa34005c2, 0x451023, +0x64182b, 0x14600005, 0xaf420090, 0x8f420098, +0x8f430144, 0x431023, 0xaf420098, 0x8f420030, +0x8f430040, 0x24420001, 0x2463ffff, 0x431024, +0xaf420030, 0x8f420030, 0x14520019, 0x0, +0x8f420000, 0x10400007, 0x0, 0xaf80004c, +0x8f82004c, 0x1040fffd, 0x0, 0x10000005, +0x0, 0xaf800048, 0x8f820048, 0x1040fffd, +0x0, 0x8f820060, 0x2403fff7, 0x431024, +0xaf820060, 0x8f420000, 0x10400004, 0x0, +0xaf80004c, 0x10000002, 0x0, 0xaf800048, 0x8fbf002c, 0x8fb20028, 0x8fb10024, 0x8fb00020, 0x3e00008, 0x27bd0030, 0x3e00008, 0x0, -0x27bdffd8, 0x3c020001, 0x34422ec0, 0xafbf0020, -0x8f4300f0, 0x8f840108, 0x2e21021, 0x54620004, +0x27bdffd8, 0xafbf0024, 0xafb00020, 0x8f4300f0, +0x8f4200ec, 0x8f900108, 0x14620017, 0x3c020001, +0x3c040001, 0x24847cac, 0x240204ea, 0xafa20010, +0xafa00014, 0x8f860144, 0x3c070001, 0x24e77cbc, +0xc002d3b, 0x3405dead, 0x8f82011c, 0x34420002, +0xaf82011c, 0x8f820220, 0x34420004, 0xaf820220, +0x8f820140, 0x3c030001, 0x431025, 0xaf820140, +0x3c020001, 0x8f4300f0, 0x34422ec0, 0x2e21021, +0x54620004, 0x24620008, 0x3c020001, 0x34422cc0, +0x2e21021, 0x401821, 0xaf4300f0, 0xac600000, +0x8f4200ec, 0x8c660004, 0x14620005, 0x3c020001, +0x26020020, 0xaf820108, 0x1000000f, 0x0, +0x8f4300f0, 0x34422ec0, 0x2e21021, 0x54620004, 0x24620008, 0x3c020001, 0x34422cc0, 0x2e21021, -0x401821, 0xaf4300f0, 0xac600000, 0x8f4200ec, -0x8c660004, 0x14620004, 0x3c020001, 0x24820020, -0x1000000f, 0xaf820108, 0x8f4300f0, 0x34422ec0, -0x2e21021, 0x54620004, 0x24620008, 0x3c020001, -0x34422cc0, 0x2e21021, 0x401821, 0x8c620004, -0x21140, 0x821021, 0xaf820108, 0xac600000, -0x8c850018, 0x30a20036, 0x1040006c, 0x30a20001, -0x8c82001c, 0x8f430040, 0x8f440034, 0x24420001, -0x2463ffff, 0x431024, 0x862021, 0xaf42002c, -0x30a20030, 0x14400006, 0xaf440034, 0x8f420034, -0x8c03023c, 0x43102b, 0x144000b4, 0x0, -0x32c20010, 0x10400028, 0x24070008, 0x8f440170, -0x8f450174, 0x8f43002c, 0x8f48000c, 0x8f860120, -0x24020080, 0xafa20010, 0xafa30014, 0xafa80018, -0x8f42010c, 0x40f809, 0x24c6001c, 0x14400011, -0x24020001, 0x3c010001, 0x370821, 0xa02240f1, -0x8f820124, 0xafa20010, 0x8f820128, 0x3c040001, -0x24846884, 0xafa20014, 0x8f46002c, 0x8f870120, -0x3c050009, 0xc002b37, 0x34a51100, 0x10000036, -0x0, 0x8f420300, 0x8f43002c, 0x24420001, -0xaf420300, 0x8f420300, 0x24020001, 0xa34205c1, -0x10000026, 0xaf430038, 0x8f440170, 0x8f450174, -0x8f43002c, 0x8f48000c, 0x8f860120, 0x24020020, -0xafa20010, 0xafa30014, 0xafa80018, 0x8f42010c, -0x40f809, 0x24c6001c, 0x14400011, 0x24020001, -0x3c010001, 0x370821, 0xa02240f0, 0x8f820124, -0xafa20010, 0x8f820128, 0x3c040001, 0x24846878, -0xafa20014, 0x8f46002c, 0x8f870120, 0x3c050009, -0xc002b37, 0x34a50900, 0x1000000f, 0x0, -0x8f420300, 0x24420001, 0xaf420300, 0x8f420300, -0x8f42002c, 0xa34005c1, 0xaf420038, 0x3c010001, -0x370821, 0xa02040f1, 0x3c010001, 0x370821, -0xa02040f0, 0xaf400034, 0x8f420314, 0x24420001, -0xaf420314, 0x10000059, 0x8f420314, 0x10400022, -0x30a27000, 0x8c85001c, 0x8f420028, 0xa22023, -0x4810003, 0x0, 0x8f420040, 0x822021, -0x8f420358, 0x8f430000, 0xaf450028, 0x441021, -0x10600007, 0xaf420358, 0xaf80004c, 0x8f82004c, +0x401821, 0x8c620004, 0x21140, 0x2021021, +0xaf820108, 0xac600000, 0x8e050018, 0x30a20036, +0x1040006d, 0x30a20001, 0x8e02001c, 0x8f430040, +0x8f440034, 0x24420001, 0x2463ffff, 0x431024, +0x862021, 0xaf42002c, 0x30a20030, 0x14400006, +0xaf440034, 0x8f420034, 0x8c03023c, 0x43102b, +0x144000cf, 0x0, 0x32c20010, 0x10400028, +0x24070008, 0x8f440170, 0x8f450174, 0x8f43002c, +0x8f48000c, 0x8f860120, 0x24020080, 0xafa20010, +0xafa30014, 0xafa80018, 0x8f42010c, 0x40f809, +0x24c6001c, 0x14400011, 0x24020001, 0x3c010001, +0x370821, 0xa02240f1, 0x8f820124, 0xafa20010, +0x8f820128, 0x3c040001, 0x24847c9c, 0xafa20014, +0x8f46002c, 0x8f870120, 0x3c050009, 0xc002d3b, +0x34a51100, 0x10000036, 0x0, 0x8f420300, +0x8f43002c, 0x24420001, 0xaf420300, 0x8f420300, +0x24020001, 0xa34205c1, 0x10000026, 0xaf430038, +0x8f440170, 0x8f450174, 0x8f43002c, 0x8f48000c, +0x8f860120, 0x24020020, 0xafa20010, 0xafa30014, +0xafa80018, 0x8f42010c, 0x40f809, 0x24c6001c, +0x14400011, 0x24020001, 0x3c010001, 0x370821, +0xa02240f0, 0x8f820124, 0xafa20010, 0x8f820128, +0x3c040001, 0x24847c90, 0xafa20014, 0x8f46002c, +0x8f870120, 0x3c050009, 0xc002d3b, 0x34a50900, +0x1000000f, 0x0, 0x8f420300, 0x24420001, +0xaf420300, 0x8f420300, 0x8f42002c, 0xa34005c1, +0xaf420038, 0x3c010001, 0x370821, 0xa02040f1, +0x3c010001, 0x370821, 0xa02040f0, 0xaf400034, +0x8f420314, 0x24420001, 0xaf420314, 0x8f420314, +0x10000073, 0x0, 0x10400025, 0x30a27000, +0x8e05001c, 0x8f420028, 0xa22023, 0x4810003, +0x0, 0x8f420040, 0x822021, 0x8f420358, +0x8f430000, 0xaf450028, 0x441021, 0xaf420358, +0x10600007, 0x0, 0xaf80004c, 0x8f82004c, 0x1040fffd, 0x0, 0x10000005, 0x0, 0xaf800048, 0x8f820048, 0x1040fffd, 0x0, 0x8f820060, 0x34420008, 0xaf820060, 0x8f420000, -0x10400003, 0x0, 0x10000038, 0xaf80004c, -0x10000036, 0xaf800048, 0x1040002f, 0x30a21000, -0x1040000c, 0x30a24000, 0x8c83001c, 0x8f420050, -0x622023, 0x4820001, 0x24840200, 0x8f42035c, -0x441021, 0xaf42035c, 0x8f420368, 0x1000001a, -0xaf430050, 0x1040000c, 0x32c28000, 0x8c83001c, -0x8f420070, 0x622023, 0x4820001, 0x24840400, -0x8f420364, 0x441021, 0xaf420364, 0x8f420368, -0x1000000d, 0xaf430070, 0x1040000e, 0x3c020800, -0x8c83001c, 0x8f420060, 0x622023, 0x4820001, -0x24840100, 0x8f420360, 0x441021, 0xaf420360, -0x8f420368, 0xaf430060, 0x441021, 0xaf420368, -0x3c020800, 0x2c21024, 0x50400008, 0x36940040, -0x10000006, 0x0, 0x30a20100, 0x10400003, -0x0, 0xc002bd4, 0x0, 0x8fbf0020, -0x3e00008, 0x27bd0028, 0x3e00008, 0x0, -0x27bdffa8, 0xafbf0050, 0xafbe004c, 0xafb50048, -0xafb30044, 0xafb20040, 0xafb1003c, 0xafb00038, -0x8f910108, 0x26220020, 0xaf820108, 0x8e320018, -0xa821, 0x32420024, 0x104001ba, 0xf021, -0x8e26001c, 0x8f43001c, 0x61100, 0x621821, -0x8c70000c, 0x9604000c, 0x962d0016, 0x9473000a, +0x10400004, 0x0, 0xaf80004c, 0x10000050, +0x0, 0xaf800048, 0x1000004d, 0x0, +0x1040002f, 0x30a21000, 0x1040000c, 0x30a24000, +0x8e03001c, 0x8f420050, 0x622023, 0x4820001, +0x24840200, 0x8f42035c, 0x441021, 0xaf42035c, +0x8f420368, 0x1000001a, 0xaf430050, 0x1040000c, +0x32c28000, 0x8e03001c, 0x8f420070, 0x622023, +0x4820001, 0x24840400, 0x8f420364, 0x441021, +0xaf420364, 0x8f420368, 0x1000000d, 0xaf430070, +0x1040000e, 0x3c020800, 0x8e03001c, 0x8f420060, +0x622023, 0x4820001, 0x24840100, 0x8f420360, +0x441021, 0xaf420360, 0x8f420368, 0xaf430060, +0x441021, 0xaf420368, 0x3c020800, 0x2c21024, +0x5040001f, 0x36940040, 0x1000001d, 0x0, +0x30a20100, 0x10400005, 0x30a20080, 0xc002dd7, +0x0, 0x10000016, 0x0, 0x14400014, +0x240205dd, 0x3c040001, 0x24847cac, 0xafa20010, +0xafa00014, 0x8f860144, 0x3c070001, 0x24e77cbc, +0xc002d3b, 0x3405dead, 0x8f82011c, 0x34420002, +0xaf82011c, 0x8f820220, 0x34420004, 0xaf820220, +0x8f820140, 0x3c030001, 0x431025, 0xaf820140, +0x8fbf0024, 0x8fb00020, 0x3e00008, 0x27bd0028, +0x3e00008, 0x0, 0x27bdff98, 0xafbf0060, +0xafbe005c, 0xafb50058, 0xafb30054, 0xafb20050, +0xafb1004c, 0xafb00048, 0x8f920108, 0x8f820104, +0x16420016, 0x26420020, 0x3c040001, 0x24847cac, +0x240205f8, 0xafa20010, 0xafa00014, 0x8f860144, +0x3c070001, 0x24e77cbc, 0xc002d3b, 0x3405dead, +0x8f82011c, 0x34420002, 0xaf82011c, 0x8f820220, +0x34420004, 0xaf820220, 0x8f820140, 0x3c030001, +0x431025, 0xaf820140, 0x26420020, 0xaf820108, +0x8e530018, 0xa3a0003f, 0x32620024, 0x1040022c, +0xafa00034, 0x8e50001c, 0x8f42001c, 0x101900, +0x431021, 0x8c51000c, 0x8f430140, 0x965e0016, +0x9455000a, 0x71182b, 0x10600014, 0x24020634, +0x3c040001, 0x24847cac, 0xafa20010, 0xafa00014, +0x8f860144, 0x3c070001, 0x24e77cbc, 0xc002d3b, +0x3405dead, 0x8f82011c, 0x34420002, 0xaf82011c, +0x8f820220, 0x34420004, 0xaf820220, 0x8f820140, +0x3c030001, 0x431025, 0xaf820140, 0x9624000c, 0x2c8305dd, 0x38828870, 0x2c420001, 0x621825, 0x10600015, 0x2821, 0x32c20040, 0x10400015, -0x24020800, 0x96030014, 0x14620012, 0x3402aaaa, -0x9603000e, 0x14620007, 0x2021, 0x96030010, -0x24020300, 0x14620004, 0x801021, 0x96020012, +0x24020800, 0x96230014, 0x14620012, 0x3402aaaa, +0x9623000e, 0x14620007, 0x2021, 0x96230010, +0x24020300, 0x14620004, 0x801021, 0x96220012, 0x2c440001, 0x801021, 0x54400006, 0x24050016, 0x10000004, 0x0, 0x24020800, 0x50820001, -0x2405000e, 0x934205c3, 0x14400008, 0x5821, -0x240b0001, 0x32620180, 0xaf4500a8, 0xaf5000a0, -0x10400002, 0xaf4600a4, 0xa34b05c3, 0x10a00085, -0x2054021, 0x91020000, 0x3821, 0x3042000f, -0x25080, 0x32c20002, 0x10400012, 0x10a1821, -0x32620002, 0x10400010, 0x32c20001, 0x1002021, -0x94820000, 0x24840002, 0xe23821, 0x83102b, -0x1440fffb, 0x30e2ffff, 0x71c02, 0x623821, -0x71c02, 0x30e2ffff, 0x623821, 0x71027, -0xa502000a, 0x32c20001, 0x1040006a, 0x32620001, -0x10400068, 0x0, 0x8f4200a8, 0x10400065, +0x2405000e, 0x934205c3, 0x14400008, 0x5021, +0x240a0001, 0x32a20180, 0xaf4500a8, 0xaf5100a0, +0x10400002, 0xaf5000a4, 0xa34a05c3, 0x10a00086, +0x2253821, 0x90e20000, 0x3021, 0x3042000f, +0x24880, 0x32c20002, 0x10400012, 0xe91821, +0x32a20002, 0x10400010, 0x32c20001, 0xe02021, +0x94820000, 0x24840002, 0xc23021, 0x83102b, +0x1440fffb, 0x30c2ffff, 0x61c02, 0x623021, +0x61c02, 0x30c2ffff, 0x623021, 0x61027, +0xa4e2000a, 0x32c20001, 0x1040006b, 0x32a20001, +0x10400069, 0x0, 0x8f4200a8, 0x10400066, 0x0, 0x8f4200a0, 0x8f4300a8, 0x431021, -0x904c0009, 0x318900ff, 0x39230006, 0x3182b, -0x39220011, 0x2102b, 0x621824, 0x1060000c, -0x3c050006, 0x8f4200a4, 0x3c040001, 0x24846894, -0xafa20010, 0x8f4200a0, 0x34a54600, 0x1203821, -0xc002b37, 0xafa20014, 0x1000004e, 0x0, -0x32c20004, 0x14400013, 0x2821, 0x316200ff, -0x14400004, 0x0, 0x95020002, 0x1000000d, -0x4a2823, 0x9505000c, 0x9502000e, 0x95030010, -0xa22821, 0xa32821, 0x95030012, 0x91040009, -0x95020002, 0xa32821, 0xa42821, 0x4a1023, -0xa22821, 0x2002021, 0x94820000, 0x24840002, -0xe23821, 0x88102b, 0x1440fffb, 0x71c02, -0x30e2ffff, 0x623821, 0x71c02, 0x30e2ffff, -0x623821, 0x1a52821, 0x51c02, 0x30a2ffff, -0x622821, 0x51c02, 0x30a2ffff, 0x622821, -0xa72823, 0x51402, 0xa22821, 0x30a5ffff, -0x50a00001, 0x3405ffff, 0x316200ff, 0x14400008, -0x318300ff, 0x8f4300a0, 0x8f4200a8, 0x624021, -0x91020000, 0x3042000f, 0x25080, 0x318300ff, -0x24020006, 0x14620003, 0x10a1021, 0x10000002, -0x24440010, 0x24440006, 0x316200ff, 0x14400006, -0x0, 0x94820000, 0xa22821, 0x51c02, -0x30a2ffff, 0x622821, 0x934205c3, 0x10400003, -0x32620100, 0x50400003, 0xa4850000, 0x52827, -0xa4850000, 0x9622000e, 0x8f43009c, 0x621821, -0x32a200ff, 0x10400007, 0xaf43009c, 0x3c024000, -0x2021025, 0xafa20020, 0x8f42009c, 0x10000003, -0x5e1025, 0xafb00020, 0x8f42009c, 0xafa20024, -0x32620080, 0x10400010, 0x32620100, 0x8f4200b4, -0x24430001, 0x210c0, 0x571021, 0xaf4300b4, -0x8fa30020, 0x8fa40024, 0x3c010001, 0x220821, -0xac2338e8, 0x3c010001, 0x220821, 0xac2438ec, -0x100000a5, 0x32c20020, 0x10400064, 0x0, +0x904b0009, 0x316800ff, 0x39030006, 0x3182b, +0x39020011, 0x2102b, 0x621824, 0x1060000d, +0x3c050006, 0x3c040001, 0x24847cc4, 0x8f4200a4, +0x34a54600, 0xafa20010, 0x8f4200a0, 0x2003021, +0x1003821, 0xc002d3b, 0xafa20014, 0x1000004e, +0x0, 0x32c20004, 0x14400013, 0x2821, +0x314200ff, 0x14400004, 0x0, 0x94e20002, +0x1000000d, 0x492823, 0x94e5000c, 0x94e2000e, +0x94e30010, 0xa22821, 0xa32821, 0x94e30012, +0x90e40009, 0x94e20002, 0xa32821, 0xa42821, +0x491023, 0xa22821, 0x2202021, 0x94820000, +0x24840002, 0xc23021, 0x87102b, 0x1440fffb, +0x61c02, 0x30c2ffff, 0x623021, 0x61c02, +0x30c2ffff, 0x623021, 0x3c52821, 0x51c02, +0x30a2ffff, 0x622821, 0x51c02, 0x30a2ffff, +0x622821, 0xa62823, 0x51402, 0xa22821, +0x30a5ffff, 0x50a00001, 0x3405ffff, 0x314200ff, +0x14400008, 0x316300ff, 0x8f4300a0, 0x8f4200a8, +0x623821, 0x90e20000, 0x3042000f, 0x24880, +0x316300ff, 0x24020006, 0x14620003, 0xe91021, +0x10000002, 0x24440010, 0x24440006, 0x314200ff, +0x14400006, 0x0, 0x94820000, 0xa22821, +0x51c02, 0x30a2ffff, 0x622821, 0x934205c3, +0x10400003, 0x32a20100, 0x50400003, 0xa4850000, +0x52827, 0xa4850000, 0x9642000e, 0x8f43009c, +0x621821, 0xaf43009c, 0x93a2003f, 0x10400007, +0x3c024000, 0x2221025, 0xafa20020, 0x8f42009c, +0x8fac0034, 0x10000003, 0x4c1025, 0xafb10020, +0x8f42009c, 0xafa20024, 0x32a20080, 0x10400027, +0x32a20100, 0x8f4200b4, 0x2c420100, 0x14400014, +0x2402076a, 0x3c040001, 0x24847cac, 0xafa20010, +0xafa00014, 0x8f860144, 0x3c070001, 0x24e77cbc, +0xc002d3b, 0x3405dead, 0x8f82011c, 0x34420002, +0xaf82011c, 0x8f820220, 0x34420004, 0xaf820220, +0x8f820140, 0x3c030001, 0x431025, 0xaf820140, 0x8f4200b4, 0x24430001, 0x210c0, 0x571021, 0xaf4300b4, 0x8fa30020, 0x8fa40024, 0x3c010001, 0x220821, 0xac2338e8, 0x3c010001, 0x220821, -0xac2438ec, 0x8f4200b4, 0x10400051, 0x3821, -0x3c090001, 0x352938e8, 0x3c08001f, 0x3508ffff, -0x240bffff, 0x340affff, 0x710c0, 0x571021, -0x491021, 0x8c430000, 0x8c440004, 0xafa30028, -0xafa4002c, 0x8f8200fc, 0x8fa30028, 0x8fa4002c, -0xac430000, 0xac440004, 0x24420008, 0xaf8200f0, -0x8f42008c, 0x2442ffff, 0xaf42008c, 0x97a2002e, -0x8f440270, 0x8f450274, 0x401821, 0x1021, -0xa32821, 0xa3302b, 0x822021, 0x862021, -0xaf440270, 0xaf450274, 0x8fa20028, 0x481024, -0x90430000, 0x30630001, 0x1460000b, 0x402021, -0x8f420278, 0x8f43027c, 0x24630001, 0x2c640001, -0x441021, 0xaf420278, 0xaf43027c, 0x8f420278, -0x1000001a, 0x8f43027c, 0x8c820000, 0x144b000e, -0x0, 0x94820004, 0x144a000b, 0x0, -0x8f420288, 0x8f43028c, 0x24630001, 0x2c640001, -0x441021, 0xaf420288, 0xaf43028c, 0x8f420288, -0x1000000a, 0x8f43028c, 0x8f420280, 0x8f430284, -0x24630001, 0x2c640001, 0x441021, 0xaf420280, -0xaf430284, 0x8f420280, 0x8f430284, 0x8f4200b4, -0x24e70001, 0xe2102b, 0x1440ffb8, 0x710c0, -0xa34005c3, 0x1000003f, 0xaf4000b4, 0x8f8200fc, -0x8fa30020, 0x8fa40024, 0xac430000, 0xac440004, -0x24420008, 0xaf8200f0, 0x8f42009c, 0x8f46008c, -0x8f440270, 0x8f450274, 0x401821, 0x1021, -0x24c6ffff, 0xaf46008c, 0xa32821, 0xa3302b, +0xac2438ec, 0x100000e7, 0x32c20020, 0x10400091, +0x0, 0x8f4200b4, 0x2c420100, 0x14400014, +0x24020778, 0x3c040001, 0x24847cac, 0xafa20010, +0xafa00014, 0x8f860144, 0x3c070001, 0x24e77cbc, +0xc002d3b, 0x3405dead, 0x8f82011c, 0x34420002, +0xaf82011c, 0x8f820220, 0x34420004, 0xaf820220, +0x8f820140, 0x3c030001, 0x431025, 0xaf820140, +0x8f4200b4, 0x24430001, 0x210c0, 0x571021, +0xaf4300b4, 0x8fa30020, 0x8fa40024, 0x3c010001, +0x220821, 0xac2338e8, 0x3c010001, 0x220821, +0xac2438ec, 0x8f4200b4, 0x10400067, 0x8821, +0x1110c0, 0x571021, 0x3c030001, 0x621821, +0x8c6338e8, 0x3c040001, 0x822021, 0x8c8438ec, +0xafa30028, 0xafa4002c, 0x8f9000fc, 0x16000014, +0x240200f4, 0x3c040001, 0x24847cac, 0xafa20010, +0xafa00014, 0x8f860144, 0x3c070001, 0x24e77cb4, +0xc002d3b, 0x3405dead, 0x8f82011c, 0x34420002, +0xaf82011c, 0x8f820220, 0x34420004, 0xaf820220, +0x8f820140, 0x3c030001, 0x431025, 0xaf820140, +0x8fa20028, 0x8fa3002c, 0xae020000, 0xae030004, +0x26020008, 0xaf8200f0, 0x8f42008c, 0x2442ffff, +0xaf42008c, 0x97a2002e, 0x8f440270, 0x8f450274, +0x401821, 0x1021, 0xa32821, 0xa3302b, 0x822021, 0x862021, 0xaf440270, 0xaf450274, -0x92020000, 0x30420001, 0x1440000c, 0x2402ffff, +0x8fa30028, 0x3c02001f, 0x3442ffff, 0x622024, +0x90820000, 0x30420001, 0x1440000c, 0x2402ffff, 0x8f420278, 0x8f43027c, 0x24630001, 0x2c640001, 0x441021, 0xaf420278, 0xaf43027c, 0x8f420278, -0x8f43027c, 0x1000001c, 0x32c20020, 0x8e030000, -0x1462000f, 0x3402ffff, 0x96030004, 0x1462000c, +0x8f43027c, 0x1000001b, 0x0, 0x8c830000, +0x1462000f, 0x3402ffff, 0x94830004, 0x1462000c, 0x0, 0x8f420288, 0x8f43028c, 0x24630001, 0x2c640001, 0x441021, 0xaf420288, 0xaf43028c, -0x8f420288, 0x8f43028c, 0x1000000b, 0x32c20020, +0x8f420288, 0x8f43028c, 0x1000000a, 0x0, 0x8f420280, 0x8f430284, 0x24630001, 0x2c640001, 0x441021, 0xaf420280, 0xaf430284, 0x8f420280, -0x8f430284, 0x32c20020, 0x10400005, 0xaf40009c, -0x8f420358, 0x2442ffff, 0xaf420358, 0x8f420358, -0x8e22001c, 0x8f430040, 0x24420001, 0x2463ffff, -0x431024, 0xaf42002c, 0x32420060, 0x14400008, -0x32c20010, 0x8f420034, 0x24420001, 0xaf420034, -0x8c03023c, 0x43102b, 0x14400102, 0x32c20010, -0x10400018, 0x24070008, 0x8f440170, 0x8f450174, -0x8f43002c, 0x8f48000c, 0x8f860120, 0x24020080, -0xafa20010, 0xafa30014, 0xafa80018, 0x8f42010c, -0x40f809, 0x24c6001c, 0x10400047, 0x24020001, -0x8f420300, 0x8f43002c, 0x24420001, 0xaf420300, -0x8f420300, 0x24020001, 0xa34205c1, 0x1000007c, -0xaf430038, 0x8f440170, 0x8f450174, 0x8f43002c, -0x8f48000c, 0x8f860120, 0x24020020, 0xafa20010, +0x8f430284, 0x8f4200b4, 0x26310001, 0x222102b, +0x1440ff9c, 0x1110c0, 0xa34005c3, 0x10000054, +0xaf4000b4, 0x8f9000fc, 0x16000014, 0x240200f4, +0x3c040001, 0x24847cac, 0xafa20010, 0xafa00014, +0x8f860144, 0x3c070001, 0x24e77cb4, 0xc002d3b, +0x3405dead, 0x8f82011c, 0x34420002, 0xaf82011c, +0x8f820220, 0x34420004, 0xaf820220, 0x8f820140, +0x3c030001, 0x431025, 0xaf820140, 0x8fa20020, +0x8fa30024, 0xae020000, 0xae030004, 0x26020008, +0xaf8200f0, 0x8f42009c, 0x8f46008c, 0x8f440270, +0x8f450274, 0x401821, 0x1021, 0x24c6ffff, +0xaf46008c, 0xa32821, 0xa3302b, 0x822021, +0x862021, 0xaf440270, 0xaf450274, 0x92220000, +0x30420001, 0x1440000c, 0x2402ffff, 0x8f420278, +0x8f43027c, 0x24630001, 0x2c640001, 0x441021, +0xaf420278, 0xaf43027c, 0x8f420278, 0x8f43027c, +0x1000001c, 0x32c20020, 0x8e230000, 0x1462000f, +0x3402ffff, 0x96230004, 0x1462000c, 0x0, +0x8f420288, 0x8f43028c, 0x24630001, 0x2c640001, +0x441021, 0xaf420288, 0xaf43028c, 0x8f420288, +0x8f43028c, 0x1000000b, 0x32c20020, 0x8f420280, +0x8f430284, 0x24630001, 0x2c640001, 0x441021, +0xaf420280, 0xaf430284, 0x8f420280, 0x8f430284, +0x32c20020, 0x10400005, 0xaf40009c, 0x8f420358, +0x2442ffff, 0xaf420358, 0x8f420358, 0x8e42001c, +0x8f430040, 0x24420001, 0x2463ffff, 0x431024, +0xaf42002c, 0x32620060, 0x14400008, 0x32c20010, +0x8f420034, 0x24420001, 0xaf420034, 0x8c03023c, +0x43102b, 0x1440011f, 0x32c20010, 0x10400018, +0x24070008, 0x8f440170, 0x8f450174, 0x8f43002c, +0x8f48000c, 0x8f860120, 0x24020080, 0xafa20010, 0xafa30014, 0xafa80018, 0x8f42010c, 0x40f809, -0x24c6001c, 0x10400057, 0x24020001, 0x10000065, -0x0, 0x32420012, 0x10400075, 0x32420001, -0x9622000e, 0x8f43009c, 0x621821, 0x32c20020, -0x10400005, 0xaf43009c, 0x8f420358, 0x2442ffff, -0xaf420358, 0x8f420358, 0x8e22001c, 0x8f430040, -0x24420001, 0x2463ffff, 0x431024, 0xaf42002c, -0x32420010, 0x14400008, 0x32c20010, 0x8f420034, -0x24420001, 0xaf420034, 0x8c03023c, 0x43102b, -0x144000bc, 0x32c20010, 0x10400028, 0x24070008, +0x24c6001c, 0x10400047, 0x24020001, 0x8f420300, +0x8f43002c, 0x24420001, 0xaf420300, 0x8f420300, +0x24020001, 0xa34205c1, 0x1000007c, 0xaf430038, 0x8f440170, 0x8f450174, 0x8f43002c, 0x8f48000c, -0x8f860120, 0x24020080, 0xafa20010, 0xafa30014, +0x8f860120, 0x24020020, 0xafa20010, 0xafa30014, 0xafa80018, 0x8f42010c, 0x40f809, 0x24c6001c, -0x14400011, 0x24020001, 0x3c010001, 0x370821, -0xa02240f1, 0x8f820124, 0xafa20010, 0x8f820128, -0x3c040001, 0x24846884, 0xafa20014, 0x8f46002c, -0x8f870120, 0x3c050009, 0xc002b37, 0x34a51100, -0x10000036, 0x0, 0x8f420300, 0x8f43002c, -0x24420001, 0xaf420300, 0x8f420300, 0x24020001, -0xa34205c1, 0x10000026, 0xaf430038, 0x8f440170, +0x10400057, 0x24020001, 0x10000065, 0x0, +0x32620012, 0x10400076, 0x32620001, 0x9642000e, +0x8f43009c, 0x621821, 0x32c20020, 0x10400005, +0xaf43009c, 0x8f420358, 0x2442ffff, 0xaf420358, +0x8f420358, 0x8e42001c, 0x8f430040, 0x24420001, +0x2463ffff, 0x431024, 0xaf42002c, 0x32620010, +0x14400008, 0x32c20010, 0x8f420034, 0x24420001, +0xaf420034, 0x8c03023c, 0x43102b, 0x144000d9, +0x32c20010, 0x10400028, 0x24070008, 0x8f440170, 0x8f450174, 0x8f43002c, 0x8f48000c, 0x8f860120, -0x24020020, 0xafa20010, 0xafa30014, 0xafa80018, +0x24020080, 0xafa20010, 0xafa30014, 0xafa80018, 0x8f42010c, 0x40f809, 0x24c6001c, 0x14400011, -0x24020001, 0x3c010001, 0x370821, 0xa02240f0, +0x24020001, 0x3c010001, 0x370821, 0xa02240f1, 0x8f820124, 0xafa20010, 0x8f820128, 0x3c040001, -0x24846878, 0xafa20014, 0x8f46002c, 0x8f870120, -0x3c050009, 0xc002b37, 0x34a50900, 0x1000000f, -0x0, 0x8f420300, 0x24420001, 0xaf420300, -0x8f420300, 0x8f42002c, 0xa34005c1, 0xaf420038, -0x3c010001, 0x370821, 0xa02040f1, 0x3c010001, -0x370821, 0xa02040f0, 0xaf400034, 0x8f420314, -0x24420001, 0xaf420314, 0x10000062, 0x8f420314, -0x10400022, 0x32427000, 0x8e25001c, 0x8f420028, +0x24847c9c, 0xafa20014, 0x8f46002c, 0x8f870120, +0x3c050009, 0xc002d3b, 0x34a51100, 0x10000036, +0x0, 0x8f420300, 0x8f43002c, 0x24420001, +0xaf420300, 0x8f420300, 0x24020001, 0xa34205c1, +0x10000026, 0xaf430038, 0x8f440170, 0x8f450174, +0x8f43002c, 0x8f48000c, 0x8f860120, 0x24020020, +0xafa20010, 0xafa30014, 0xafa80018, 0x8f42010c, +0x40f809, 0x24c6001c, 0x14400011, 0x24020001, +0x3c010001, 0x370821, 0xa02240f0, 0x8f820124, +0xafa20010, 0x8f820128, 0x3c040001, 0x24847c90, +0xafa20014, 0x8f46002c, 0x8f870120, 0x3c050009, +0xc002d3b, 0x34a50900, 0x1000000f, 0x0, +0x8f420300, 0x24420001, 0xaf420300, 0x8f420300, +0x8f42002c, 0xa34005c1, 0xaf420038, 0x3c010001, +0x370821, 0xa02040f1, 0x3c010001, 0x370821, +0xa02040f0, 0xaf400034, 0x8f420314, 0x24420001, +0xaf420314, 0x8f420314, 0x1000007e, 0x0, +0x10400025, 0x32627000, 0x8e45001c, 0x8f420028, 0xa22023, 0x4810003, 0x0, 0x8f420040, 0x822021, 0x8f420358, 0x8f430000, 0xaf450028, -0x441021, 0x10600007, 0xaf420358, 0xaf80004c, -0x8f82004c, 0x1040fffd, 0x0, 0x10000005, -0x0, 0xaf800048, 0x8f820048, 0x1040fffd, -0x0, 0x8f820060, 0x34420008, 0xaf820060, -0x8f420000, 0x10400003, 0x0, 0x10000041, -0xaf80004c, 0x1000003f, 0xaf800048, 0x1040002f, -0x32421000, 0x1040000c, 0x32424000, 0x8e23001c, -0x8f420050, 0x622023, 0x4820001, 0x24840200, -0x8f42035c, 0x441021, 0xaf42035c, 0x8f420368, -0x1000001a, 0xaf430050, 0x1040000c, 0x32c28000, -0x8e23001c, 0x8f420070, 0x622023, 0x4820001, -0x24840400, 0x8f420364, 0x441021, 0xaf420364, -0x8f420368, 0x1000000d, 0xaf430070, 0x1040000e, -0x3c020800, 0x8e23001c, 0x8f420060, 0x622023, -0x4820001, 0x24840100, 0x8f420360, 0x441021, -0xaf420360, 0x8f420368, 0xaf430060, 0x441021, -0xaf420368, 0x3c020800, 0x2c21024, 0x50400011, -0x36940040, 0x1000000f, 0x0, 0x32420048, -0x10400007, 0x24150001, 0x8e22001c, 0x3c03ffff, -0x43f024, 0x3042ffff, 0x1000fd75, 0xae22001c, -0x32420100, 0x10400003, 0x0, 0xc002bd4, -0x0, 0x8fbf0050, 0x8fbe004c, 0x8fb50048, -0x8fb30044, 0x8fb20040, 0x8fb1003c, 0x8fb00038, -0x3e00008, 0x27bd0058, 0x3e00008, 0x0, -0x0, 0x0, 0x0, 0x8f8300e4, -0x8f8200e0, 0x2404fff8, 0x441024, 0x621026, -0x2102b, 0x21023, 0x3e00008, 0x621024, -0x3e00008, 0x0, 0x27bdffe0, 0xafbf001c, -0xafb00018, 0x8f8600c4, 0x8f8400e0, 0x8f8500e4, -0x2402fff8, 0x821824, 0x10a30009, 0x27623ff8, -0x14a20002, 0x24a20008, 0x27623000, 0x408021, -0x16030005, 0x30820004, 0x10400004, 0xc02021, -0x10000022, 0x1021, 0x8e040000, 0x8f42011c, -0x14a20003, 0x0, 0x8f420120, 0xaf420114, -0x8ca30000, 0x8f420148, 0x831823, 0x43102b, -0x10400003, 0x0, 0x8f420148, 0x621821, -0x94a20006, 0x24420050, 0x62102b, 0x1440000f, -0xa01021, 0xafa40010, 0xafa30014, 0x8ca60000, -0x8ca70004, 0x3c040001, 0xc002b37, 0x24846954, -0x8f42020c, 0x24420001, 0xaf42020c, 0x8f42020c, -0x1021, 0xaf9000e8, 0xaf9000e4, 0x8fbf001c, -0x8fb00018, 0x3e00008, 0x27bd0020, 0x3e00008, -0x0, 0x8f8400e0, 0x8f8800c4, 0x8f8300e8, -0x2402fff8, 0x823824, 0xe32023, 0x2c821000, -0x50400001, 0x24841000, 0x420c2, 0x801821, -0x8f440258, 0x8f45025c, 0x1021, 0xa32821, -0xa3302b, 0x822021, 0x862021, 0xaf440258, -0xaf45025c, 0x8f8300c8, 0x8f420148, 0x1032023, -0x82102b, 0x14400004, 0x801821, 0x8f420148, -0x822021, 0x801821, 0x8f440250, 0x8f450254, -0x1021, 0xa32821, 0xa3302b, 0x822021, -0x862021, 0xaf440250, 0xaf450254, 0xaf8800c8, -0xaf8700e4, 0x3e00008, 0xaf8700e8, 0x27bdff30, -0x240a0001, 0xafbf00c8, 0xafbe00c4, 0xafb500c0, -0xafb300bc, 0xafb200b8, 0xafb100b4, 0xafb000b0, -0xa3a00097, 0xafa00044, 0xafaa005c, 0x934205c4, -0xa7a0008e, 0x1040000a, 0xa7a00086, 0x8f4b00c4, -0xafab0064, 0x8f4a00c0, 0xafaa006c, 0x8f4b00cc, -0xafab0074, 0x8f4a00c8, 0x10000129, 0xafaa007c, +0x441021, 0xaf420358, 0x10600007, 0x0, +0xaf80004c, 0x8f82004c, 0x1040fffd, 0x0, +0x10000005, 0x0, 0xaf800048, 0x8f820048, +0x1040fffd, 0x0, 0x8f820060, 0x34420008, +0xaf820060, 0x8f420000, 0x10400004, 0x0, +0xaf80004c, 0x1000005b, 0x0, 0xaf800048, +0x10000058, 0x0, 0x1040002f, 0x32621000, +0x1040000c, 0x32624000, 0x8e43001c, 0x8f420050, +0x622023, 0x4820001, 0x24840200, 0x8f42035c, +0x441021, 0xaf42035c, 0x8f420368, 0x1000001a, +0xaf430050, 0x1040000c, 0x32c28000, 0x8e43001c, +0x8f420070, 0x622023, 0x4820001, 0x24840400, +0x8f420364, 0x441021, 0xaf420364, 0x8f420368, +0x1000000d, 0xaf430070, 0x1040000e, 0x3c020800, +0x8e43001c, 0x8f420060, 0x622023, 0x4820001, +0x24840100, 0x8f420360, 0x441021, 0xaf420360, +0x8f420368, 0xaf430060, 0x441021, 0xaf420368, +0x3c020800, 0x2c21024, 0x5040002a, 0x36940040, +0x10000028, 0x0, 0x32620048, 0x10400009, +0x240c0001, 0x8e42001c, 0x3c03ffff, 0xa3ac003f, +0x431824, 0x3042ffff, 0xafa30034, 0x1000fcfd, +0xae42001c, 0x32620100, 0x10400005, 0x32620080, +0xc002dd7, 0x0, 0x10000016, 0x0, +0x14400014, 0x24020896, 0x3c040001, 0x24847cac, +0xafa20010, 0xafa00014, 0x8f860144, 0x3c070001, +0x24e77cbc, 0xc002d3b, 0x3405dead, 0x8f82011c, +0x34420002, 0xaf82011c, 0x8f820220, 0x34420004, +0xaf820220, 0x8f820140, 0x3c030001, 0x431025, +0xaf820140, 0x8fbf0060, 0x8fbe005c, 0x8fb50058, +0x8fb30054, 0x8fb20050, 0x8fb1004c, 0x8fb00048, +0x3e00008, 0x27bd0068, 0x3e00008, 0x0, +0x8f8300e4, 0x8f8200e0, 0x2404fff8, 0x441024, +0x621026, 0x2102b, 0x21023, 0x3e00008, +0x621024, 0x3e00008, 0x0, 0x27bdffe0, +0xafbf001c, 0xafb00018, 0x8f8600c4, 0x8f8400e0, +0x8f8500e4, 0x2402fff8, 0x821824, 0x10a30009, +0x27623ff8, 0x14a20002, 0x24a20008, 0x27623000, +0x408021, 0x16030005, 0x30820004, 0x10400004, +0xc02021, 0x10000022, 0x1021, 0x8e040000, +0x8f42011c, 0x14a20003, 0x0, 0x8f420120, +0xaf420114, 0x8ca30000, 0x8f420148, 0x831823, +0x43102b, 0x10400003, 0x0, 0x8f420148, +0x621821, 0x94a20006, 0x24420050, 0x62102b, +0x1440000f, 0xa01021, 0xafa40010, 0xafa30014, +0x8ca60000, 0x8ca70004, 0x3c040001, 0xc002d3b, +0x24847d94, 0x8f42020c, 0x24420001, 0xaf42020c, +0x8f42020c, 0x1021, 0xaf9000e8, 0xaf9000e4, +0x8fbf001c, 0x8fb00018, 0x3e00008, 0x27bd0020, +0x3e00008, 0x0, 0x8f8300e4, 0x27623ff8, +0x14620002, 0x24620008, 0x27623000, 0x401821, +0xaf8300e8, 0xaf8300e4, 0x3e00008, 0x0, +0x3e00008, 0x0, 0x8f8400e0, 0x8f8800c4, +0x8f8300e8, 0x2402fff8, 0x823824, 0xe32023, +0x2c821000, 0x50400001, 0x24841000, 0x420c2, +0x801821, 0x8f440258, 0x8f45025c, 0x1021, +0xa32821, 0xa3302b, 0x822021, 0x862021, +0xaf440258, 0xaf45025c, 0x8f8300c8, 0x8f420148, +0x1032023, 0x82102b, 0x14400004, 0x801821, +0x8f420148, 0x822021, 0x801821, 0x8f440250, +0x8f450254, 0x1021, 0xa32821, 0xa3302b, +0x822021, 0x862021, 0xaf440250, 0xaf450254, +0xaf8800c8, 0xaf8700e4, 0xaf8700e8, 0x3e00008, +0x0, 0x27bdff28, 0x240a0001, 0xafbf00d0, +0xafbe00cc, 0xafb500c8, 0xafb300c4, 0xafb200c0, +0xafb100bc, 0xafb000b8, 0xa3a0009f, 0xafa0004c, +0xafaa0064, 0xa7a00096, 0xafa00040, 0x934205c4, +0x8821, 0x1040000a, 0xa7a0008e, 0x8f4b00c4, +0xafab006c, 0x8f4a00c0, 0xafaa0074, 0x8f4b00cc, +0xafab007c, 0x8f4a00c8, 0x100001bc, 0xafaa0084, 0x8f420114, 0x40f809, 0x0, 0x403021, -0x10c0034f, 0x0, 0x8cc20000, 0x8cc30004, +0x10c00435, 0x0, 0x8cc20000, 0x8cc30004, 0xafa20020, 0xafa30024, 0x8fab0024, 0x8faa0020, -0x3162ffff, 0x2442fffc, 0xafa2006c, 0x3c020006, -0x2c21024, 0xafab007c, 0x14400015, 0xafaa0064, +0x3162ffff, 0x2442fffc, 0xafa20074, 0x3c020006, +0x2c21024, 0xafab0084, 0x14400015, 0xafaa006c, 0x91420000, 0x30420001, 0x10400011, 0x2402ffff, 0x8d430000, 0x14620004, 0x3402ffff, 0x95430004, -0x1062000b, 0x0, 0xc0024ba, 0x8fa40064, +0x1062000b, 0x0, 0xc0025dd, 0x8fa4006c, 0x304200ff, 0x14400006, 0x0, 0x8f420118, -0x40f809, 0x0, 0x1000032d, 0x0, +0x40f809, 0x0, 0x10000413, 0x0, 0x8fa20024, 0x3c03ffbf, 0x3463ffff, 0x431024, 0x3c03ffff, 0x431824, 0x14600003, 0xafa20024, 0x10000040, 0x1821, 0x3c020080, 0x621024, @@ -2279,209 +2473,267 @@ 0x8f4201c0, 0x24420001, 0xaf4201c0, 0x8f4201c0, 0x3c020020, 0x621024, 0x10400006, 0x24030001, 0x8f420388, 0x24420001, 0xaf420388, 0x8f420388, -0x24030001, 0x8c020260, 0x8fab006c, 0x4b102b, +0x24030001, 0x8c020260, 0x8fab0074, 0x4b102b, 0x10400014, 0x307000ff, 0x8f4201e8, 0x24420001, -0xaf4201e8, 0x8f4201e8, 0x8faa007c, 0x8f8200e0, -0x354a0100, 0xafaa007c, 0xafa20010, 0x8f8200e4, -0x24100001, 0x3c040001, 0x24846960, 0xafa20014, -0x8fa60020, 0x8fa70024, 0x3c050007, 0xc002b37, -0x34a50800, 0x12000010, 0x3c020080, 0x2c21024, -0x1440000e, 0x32c20400, 0x8fab007c, 0x3c020080, +0xaf4201e8, 0x8f4201e8, 0x8faa0084, 0x8f8200e0, +0x354a0100, 0xafaa0084, 0xafa20010, 0x8f8200e4, +0x24100001, 0x3c040001, 0x24847da0, 0xafa20014, +0x8fa60020, 0x8fa70024, 0x3c050007, 0xc002d3b, +0x34a50800, 0x12000011, 0x3c020080, 0x2c21024, +0x1440000f, 0x32c20400, 0x8fab0084, 0x3c020080, 0x34420100, 0x1621024, 0x10400005, 0x0, -0x8f42020c, 0x24420001, 0xaf42020c, 0x8f42020c, -0x100002b0, 0x8fa3006c, 0x32c20400, 0x10400015, -0x34028100, 0x8faa0064, 0x9543000c, 0x14620012, -0x3c020100, 0x240b0200, 0xa7ab008e, 0x9542000e, -0x8d430008, 0x8d440004, 0x8d450000, 0x8faa006c, -0x8fab0064, 0x254afffc, 0xafaa006c, 0xa7a20086, -0xad63000c, 0xad640008, 0xad650004, 0x256b0004, -0xafab0064, 0x3c020100, 0x2c21024, 0x10400004, -0x0, 0x8faa006c, 0x254a0004, 0xafaa006c, -0x8f4200bc, 0x5040000a, 0xafa00074, 0x8fab006c, -0x4b102b, 0x50400006, 0xafa00074, 0x8f4200bc, -0x1621023, 0xafa20074, 0x8f4a00bc, 0xafaa006c, -0x8f420080, 0x8fab006c, 0x4b102b, 0x10400056, -0x32c28000, 0x1040005e, 0x240a0003, 0x32c21000, -0x1040005b, 0xafaa005c, 0x10000058, 0x240b0004, -0x8f420350, 0x2403ffbf, 0x283a024, 0x24420001, -0xaf420350, 0x1000024f, 0x8f420350, 0x2c2b025, -0x2402ffbf, 0x282a024, 0x8f830128, 0x3c040001, -0x24846990, 0x26620001, 0xafa20014, 0xafa30010, -0x8f860120, 0x8f870124, 0x3c050007, 0xc002b37, -0x34a52250, 0x1000023f, 0x0, 0x2c2b025, -0x2402ffbf, 0x282a024, 0x8f830128, 0x3c040001, -0x24846990, 0x24020002, 0xafa20014, 0xafa30010, -0x8f860120, 0x8f870124, 0x3c050007, 0xc002b37, -0x34a52450, 0x1000022f, 0x0, 0x8ea20000, -0x8ea30004, 0x3c040001, 0x248469a8, 0xafb00010, -0xafbe0014, 0x8ea70018, 0x34a52800, 0xc002b37, -0x603021, 0x10000223, 0x0, 0xa6b1000a, -0x8f820124, 0x3c040001, 0x248469b0, 0xafbe0014, -0xafa20010, 0x8f460044, 0x8f870120, 0x3c050007, -0xc002b37, 0x34a53000, 0x10000216, 0x0, -0xa6b1000a, 0xa6b2000e, 0x8f820124, 0x3c040001, -0x248469bc, 0xafbe0014, 0xafa20010, 0x8f460044, -0x8f870120, 0x3c050007, 0xc002b37, 0x34a53200, -0x10000208, 0x0, 0x8f420084, 0x8faa006c, -0x4a102b, 0x14400007, 0x3c020001, 0x2c21024, -0x10400004, 0x0, 0x240b0002, 0xafab005c, -0x8faa006c, 0x1140021b, 0x27ab0020, 0xafab00a4, -0x3c0a001f, 0x354affff, 0xafaa009c, 0x8fab005c, -0x240a0001, 0x556a0021, 0x240a0002, 0x8f430054, -0x8f420050, 0x1062000b, 0x274b0054, 0x8f5e0054, -0x3403ecc0, 0xafab004c, 0x27c20001, 0x304201ff, -0xafa20054, 0x1e1140, 0x431021, 0x1000006b, -0x2e2a821, 0x8f420044, 0x8faa006c, 0x3c040001, -0x2484696c, 0xafaa0014, 0xafa20010, 0x8f460054, -0x8f470050, 0x3c050007, 0xc002b37, 0x34a51300, -0x8f430350, 0x2402ffbf, 0x282a024, 0x24630001, -0xaf430350, 0x100001d3, 0x8f420350, 0x156a001d, -0x0, 0x8f430074, 0x8f420070, 0x1062000a, -0x274b0074, 0x8f5e0074, 0xafab004c, 0x27c20001, -0x304203ff, 0xafa20054, 0x1e1140, 0x24426cc0, -0x1000004a, 0x2e2a821, 0x8f420044, 0x8faa006c, -0x3c040001, 0x24846978, 0x3c050007, 0xafaa0014, -0xafa20010, 0x8f460074, 0x8f470070, 0x34a51500, -0x240b0001, 0xc002b37, 0xafab005c, 0x1000ffc3, -0x0, 0x8f430064, 0x8f420060, 0x1062001a, -0x274a0064, 0x8f5e0064, 0x8fab005c, 0xafaa004c, -0x27c20001, 0x304200ff, 0xafa20054, 0x24020004, -0x1562000e, 0x1e1140, 0x1e1180, 0x24420cc0, -0x2e21021, 0xafa20044, 0x9442002a, 0x8faa0044, -0x8fab006c, 0x4b102b, 0x10400024, 0x25550020, -0x240a0001, 0x10000021, 0xa3aa0097, 0x24424cc0, -0x1000001e, 0x2e2a821, 0x8f420044, 0x8fab006c, -0x3c040001, 0x24846984, 0xafab0014, 0xafa20010, -0x8f460064, 0x8f470060, 0x3c050007, 0xc002b37, -0x34a51800, 0x3c020008, 0x2c21024, 0x1440ff34, -0x0, 0x8f420370, 0x240a0001, 0xafaa005c, -0x24420001, 0xaf420370, 0x1000ff90, 0x8f420370, -0x27a30036, 0x131040, 0x621821, 0x94620000, -0x441021, 0x10000020, 0xa4620000, 0x8fab0064, -0xaeab0018, 0x93a20097, 0x10400072, 0x9821, -0x8faa0044, 0x8fa4006c, 0x8fa300a4, 0x25420020, -0xafa20028, 0x25420008, 0xafa20030, 0x25420010, -0xafaa002c, 0xafa20034, 0x9542002a, 0xa7a20038, -0x95420018, 0xa7a2003a, 0x9542001a, 0xa7a2003c, -0x9542001c, 0xa7a2003e, 0x94620018, 0x24630002, -0x822023, 0x1880ffde, 0x26730001, 0x2e620004, -0x1440fff9, 0x0, 0x8f4200fc, 0x26650001, -0xa2102a, 0x1440002b, 0x24030001, 0x8f83012c, -0x10600023, 0x0, 0x8f820124, 0x431023, -0x22143, 0x58800001, 0x24840040, 0x8f820128, -0x431023, 0x21943, 0x58600001, 0x24630040, -0x64102a, 0x54400001, 0x602021, 0xaf4400fc, -0x8f4200fc, 0xa2102a, 0x10400011, 0x24030001, -0x10000015, 0x306200ff, 0x8fab0064, 0x96070018, -0xafab0010, 0x8e220008, 0x3c040001, 0x2484699c, -0x8c430004, 0x8c420000, 0x34a52400, 0x2403021, -0xc002b37, 0xafa30014, 0x1000002b, 0x0, -0x8f420334, 0x1821, 0x24420001, 0xaf420334, -0x8f420334, 0x306200ff, 0x5040fedc, 0x3c020800, -0x12600021, 0x9021, 0x8fb100a4, 0x2208021, -0x8e220008, 0x96070018, 0x8fa60064, 0x8c440000, -0x8c450004, 0x240a0001, 0xafaa0010, 0xafbe0014, -0x8f420008, 0xafa20018, 0x8f42010c, 0x40f809, -0x0, 0x1040ffd8, 0x3c050007, 0x96020018, -0x8fab0064, 0x8faa009c, 0x1625821, 0x14b102b, -0x10400004, 0xafab0064, 0x8f420148, 0x1625823, -0xafab0064, 0x26100002, 0x26520001, 0x253102b, -0x1440ffe3, 0x26310004, 0x8fb0006c, 0x10000036, -0x97b10038, 0x8f4200fc, 0x24050002, 0xa2102a, -0x1440001b, 0x24030001, 0x8f83012c, 0x10600013, -0x0, 0x8f820124, 0x431023, 0x22143, -0x58800001, 0x24840040, 0x8f820128, 0x431023, -0x21943, 0x58600001, 0x24630040, 0x64102a, -0x54400001, 0x602021, 0xaf4400fc, 0x8f4200fc, -0xa2102a, 0x14400006, 0x24030001, 0x8f420334, -0x1821, 0x24420001, 0xaf420334, 0x8f420334, -0x306200ff, 0x1040fea5, 0x3c020800, 0x96b1000a, -0x8fb0006c, 0x3223ffff, 0x70102b, 0x54400001, -0x608021, 0x8ea40000, 0x8ea50004, 0x240b0001, -0xafab0010, 0xafbe0014, 0x8f420008, 0x8fa60064, -0xafa20018, 0x8f42010c, 0x40f809, 0x2003821, -0x1040fea2, 0x3c050007, 0x96a3000e, 0x97aa008e, -0x11400007, 0x609021, 0x934205c4, 0x14400004, -0x0, 0x97ab0086, 0x6a1825, 0xa6ab0016, -0x8faa007c, 0x3c02ffff, 0x1421024, 0x10400003, -0xa1402, 0x34630400, 0xa6a20014, 0x8fab006c, -0x560b0072, 0xa6a3000e, 0x34620004, 0xa6a2000e, -0x8faa0074, 0x16a1021, 0xa6a2000a, 0x8f430044, -0x8f4401a0, 0x8f4501a4, 0x34028000, 0xafa20010, -0x8f420044, 0x2a03021, 0x24070020, 0xafa20014, -0x8f42000c, 0x31940, 0x604821, 0xafa20018, -0x8f42010c, 0x4021, 0xa92821, 0xa9182b, -0x882021, 0x40f809, 0x832021, 0x5040fe7f, -0xa6b2000e, 0x8f420368, 0xafa0006c, 0xa34005c4, -0x2442ffff, 0xaf420368, 0x8fab005c, 0x240a0001, -0x8f420368, 0x156a0006, 0x240a0002, 0x8f42035c, -0x2442ffff, 0xaf42035c, 0x1000000c, 0x8f42035c, -0x156a0006, 0x0, 0x8f420364, 0x2442ffff, -0xaf420364, 0x10000005, 0x8f420364, 0x8f420360, -0x2442ffff, 0xaf420360, 0x8f420360, 0x8faa0054, -0x8fab004c, 0xad6a0000, 0x8f420044, 0x8f440088, -0x8f430078, 0x24420001, 0x441024, 0x24630001, -0xaf420044, 0xaf430078, 0x8c020240, 0x62182b, -0x14600075, 0x24070008, 0x8f440168, 0x8f45016c, -0x8f430044, 0x8f48000c, 0x8f860120, 0x24020040, -0xafa20010, 0xafa30014, 0xafa80018, 0x8f42010c, -0x40f809, 0x24c6001c, 0x14400011, 0x240b0001, -0x3c010001, 0x370821, 0xa02b40f2, 0x8f820124, -0xafa20010, 0x8f820128, 0x3c040001, 0x2484694c, -0xafa20014, 0x8f460044, 0x8f870120, 0x3c050009, -0xc002b37, 0x34a51300, 0x1000000b, 0x0, -0x8f420304, 0x24420001, 0xaf420304, 0x8f420304, -0x8f420044, 0xaf42007c, 0x3c010001, 0x370821, -0xa02040f2, 0xaf400078, 0x8f420318, 0x24420001, -0xaf420318, 0x10000048, 0x8f420318, 0xa6b0000a, +0x8f42020c, 0x24420001, 0xaf42020c, 0x8f42020c, +0x8fa30074, 0x10000394, 0x0, 0x32c20400, +0x10400015, 0x34028100, 0x8faa006c, 0x9543000c, +0x14620012, 0x3c020100, 0x240b0200, 0xa7ab0096, +0x9542000e, 0x8d430008, 0x8d440004, 0x8d450000, +0x8faa0074, 0x8fab006c, 0x254afffc, 0xafaa0074, +0xa7a2008e, 0xad63000c, 0xad640008, 0xad650004, +0x256b0004, 0xafab006c, 0x3c020100, 0x2c21024, +0x10400004, 0x0, 0x8faa0074, 0x254a0004, +0xafaa0074, 0x16000005, 0x24020800, 0x8fab006c, +0x9563000c, 0x50620001, 0x2411000e, 0x8f4200bc, +0x5040000a, 0xafa0007c, 0x8faa0074, 0x4a102b, +0x50400006, 0xafa0007c, 0x8f4200bc, 0x1421023, +0xafa2007c, 0x8f4b00bc, 0xafab0074, 0x8f420080, +0x8faa0074, 0x4a102b, 0x104000e2, 0x32c28000, +0x104000ea, 0x32c21000, 0x10400075, 0x240b0004, +0x3c021000, 0x2c21024, 0x104000e4, 0xafab0064, +0x122000e2, 0x0, 0x8faa006c, 0x8fab0074, +0x1711023, 0x2c420014, 0x144000dd, 0x1512821, +0x24a30006, 0x90a20000, 0x3c07001f, 0x34e7ffff, +0x3042000f, 0x24080, 0xe3102b, 0x10400003, +0x0, 0x8f420148, 0x621823, 0x94620000, +0x30421fff, 0x10400003, 0x2281021, 0x100000cb, +0xafa20040, 0x24a30009, 0xe3102b, 0x10400003, +0x0, 0x8f420148, 0x621823, 0x90630000, +0x24020006, 0x1462002b, 0x24020011, 0x94a20002, +0x2c420028, 0x144000bd, 0xa83021, 0xe6102b, +0x10400004, 0x24c3000c, 0x8f420148, 0xc23023, +0x24c3000c, 0xe3102b, 0x10400003, 0x0, +0x8f420148, 0x621823, 0x90640000, 0x94a30002, +0x308200f0, 0x22082, 0x2281021, 0x442021, +0x2c6300b8, 0x146000a9, 0xafa40040, 0x94c20000, +0x38430801, 0x2c630001, 0x3842639d, 0x2c420001, +0x621825, 0x14600009, 0x24820090, 0x94c20002, +0x38430801, 0x2c630001, 0x3842639d, 0x2c420001, +0x621825, 0x10600099, 0x24820090, 0x10000097, +0xafa20040, 0x14620095, 0x0, 0x94a20002, +0x2c42001c, 0x14400091, 0x2283021, 0x94a30002, +0x24c20008, 0x2c63009c, 0x1460008c, 0xafa20040, +0xa82021, 0xe4102b, 0x10400003, 0x0, +0x8f420148, 0x822023, 0x94820000, 0x38430801, +0x2c630001, 0x3842639d, 0x2c420001, 0x621825, +0x14600009, 0x24c20088, 0x94820002, 0x38430801, +0x2c630001, 0x3842639d, 0x2c420001, 0x621825, +0x10600076, 0x24c20088, 0x10000074, 0xafa20040, +0x10000071, 0x240a0003, 0x8f420350, 0x2403ffbf, +0x283a024, 0x24420001, 0xaf420350, 0x8f420350, +0x100002b8, 0x0, 0x2c2b025, 0x2402ffbf, +0x282a024, 0x8f830128, 0x3c040001, 0x24847dd8, +0x26620001, 0xafa20014, 0xafa30010, 0x8f860120, +0x8f870124, 0x3c050007, 0xc002d3b, 0x34a52250, +0x100002a8, 0x0, 0x2c2b025, 0x2402ffbf, +0x282a024, 0x8f830128, 0x3c040001, 0x24847dd8, +0x24020002, 0xafa20014, 0xafa30010, 0x8f860120, +0x8f870124, 0x3c050007, 0xc002d3b, 0x34a52450, +0x10000298, 0x0, 0x8ea20000, 0x8ea30004, +0x3c040001, 0x24847df0, 0xafb00010, 0xafbe0014, +0x8ea70018, 0x34a52800, 0xc002d3b, 0x603021, +0x3c040001, 0x24847d84, 0x1000001f, 0x240205a6, +0xa6b1000a, 0x8f820124, 0x3c040001, 0x24847df8, +0xafbe0014, 0xafa20010, 0x8f460044, 0x8f870120, +0x3c050007, 0xc002d3b, 0x34a53000, 0x3c040001, +0x24847d84, 0x10000010, 0x240205e2, 0xa6b1000a, +0xa6b2000e, 0x8f820124, 0x3c040001, 0x24847e04, +0xafbe0014, 0xafa20010, 0x8f460044, 0x8f870120, +0x3c050007, 0xc002d3b, 0x34a53200, 0x3c040001, +0x24847d84, 0x24020617, 0xafa20010, 0xafa00014, +0x8f860144, 0x3c070001, 0x24e77dd0, 0xc002d3b, +0x3405dead, 0x8f82011c, 0x34420002, 0xaf82011c, +0x8f820220, 0x34420004, 0xaf820220, 0x8f820140, +0x3c030001, 0x431025, 0xaf820140, 0x10000259, +0x0, 0x8f420084, 0x8fab0074, 0x4b102b, +0x14400007, 0x3c020001, 0x2c21024, 0x10400004, +0x0, 0x240a0002, 0xafaa0064, 0x8fab0074, +0x1160026d, 0x27aa0020, 0xafaa00ac, 0x3c0b001f, +0x356bffff, 0xafab00a4, 0x8faa0064, 0x240b0001, +0x154b0022, 0x24020002, 0x8f430054, 0x8f420050, +0x1062000b, 0x274a0054, 0x8f5e0054, 0x3403ecc0, +0xafaa0054, 0x27c20001, 0x304201ff, 0xafa2005c, +0x1e1140, 0x431021, 0x10000077, 0x2e2a821, +0x8f420044, 0x8fab0074, 0x3c040001, 0x24847dac, +0xafab0014, 0xafa20010, 0x8f460054, 0x8f470050, +0x3c050007, 0xc002d3b, 0x34a51300, 0x8f430350, +0x2402ffbf, 0x282a024, 0x24630001, 0xaf430350, +0x8f420350, 0x10000223, 0x0, 0x1542001d, +0x0, 0x8f430074, 0x8f420070, 0x1062000a, +0x274b0074, 0x8f5e0074, 0xafab0054, 0x27c20001, +0x304203ff, 0xafa2005c, 0x1e1140, 0x24426cc0, +0x10000055, 0x2e2a821, 0x8f420044, 0x8faa0074, +0x3c040001, 0x24847db8, 0x3c050007, 0xafaa0014, +0xafa20010, 0x8f460074, 0x8f470070, 0x34a51500, +0x240b0001, 0xc002d3b, 0xafab0064, 0x1000ffc2, +0x0, 0x8f430064, 0x8f420060, 0x1062002b, +0x274a0064, 0x8f5e0064, 0x8fab0064, 0xafaa0054, +0x27c20001, 0x304200ff, 0xafa2005c, 0x24020004, +0x1562001f, 0x1e1140, 0x1e1180, 0x24420cc0, +0x2e21021, 0xafa2004c, 0x24550020, 0x3c021000, +0x2c21024, 0x1040000e, 0x0, 0x8faa004c, +0x8fab0074, 0x9542002a, 0x4b102b, 0x54400006, +0x240a0001, 0x8fa20040, 0x10400027, 0x0, +0x104b0025, 0x240a0001, 0x10000023, 0xa3aa009f, +0x8fab004c, 0x8faa0074, 0x9562002a, 0x4a102b, +0x1040001d, 0x240b0001, 0x1000001b, 0xa3ab009f, +0x24424cc0, 0x10000018, 0x2e2a821, 0x8f420044, +0x8faa0074, 0x3c040001, 0x24847dc4, 0xafaa0014, +0xafa20010, 0x8f460064, 0x8f470060, 0x3c050007, +0xc002d3b, 0x34a51800, 0x3c020008, 0x2c21024, +0x1440ff09, 0x0, 0x8f420370, 0x240b0001, +0xafab0064, 0x24420001, 0xaf420370, 0x8f420370, +0x1000ff7d, 0x0, 0x8faa006c, 0xaeaa0018, +0x93a2009f, 0x104000ae, 0x24050002, 0x8fab004c, +0x8fa40040, 0x25620020, 0xafa20028, 0x25620008, +0xafa20030, 0x25620010, 0xafab002c, 0x1080000e, +0xafa20034, 0x9563002a, 0x83102b, 0x54400001, +0x801821, 0x1000000b, 0xa7a30038, 0x27a30036, +0x131040, 0x621821, 0x94620000, 0x441021, +0x10000016, 0xa4620000, 0x8faa004c, 0x9542002a, +0xa7a20038, 0x8fab004c, 0x8fa40074, 0x8fa300ac, +0x95620018, 0xa7a2003a, 0x9562001a, 0xa7a2003c, +0x9562001c, 0x9821, 0xa7a2003e, 0x94620018, +0x24630002, 0x822023, 0x1880ffe8, 0x26730001, +0x2e620004, 0x1440fff9, 0x0, 0x18800014, +0x24020544, 0x3c040001, 0x24847d84, 0xafa20010, +0xafa00014, 0x8f860144, 0x3c070001, 0x24e77dd0, +0xc002d3b, 0x3405dead, 0x8f82011c, 0x34420002, +0xaf82011c, 0x8f820220, 0x34420004, 0xaf820220, +0x8f820140, 0x3c030001, 0x431025, 0xaf820140, +0x8f4200fc, 0x26650001, 0xa2102a, 0x1440003f, +0x24030001, 0x8f83012c, 0x10600037, 0x0, +0x8f820124, 0x431023, 0x22143, 0x58800001, +0x24840040, 0x8f820128, 0x431023, 0x21943, +0x58600001, 0x24630040, 0x64102a, 0x54400001, +0x602021, 0xaf4400fc, 0x8f4200fc, 0xa2102a, +0x10400025, 0x24030001, 0x10000029, 0x306200ff, +0x8faa006c, 0x96070018, 0xafaa0010, 0x8e220008, +0x3c040001, 0x24847de4, 0x8c430004, 0x8c420000, +0x34a52400, 0x2403021, 0xc002d3b, 0xafa30014, +0x3c040001, 0x24847d84, 0x24020568, 0xafa20010, +0xafa00014, 0x8f860144, 0x3c070001, 0x24e77dd0, +0xc002d3b, 0x3405dead, 0x8f82011c, 0x34420002, +0xaf82011c, 0x8f820220, 0x34420004, 0xaf820220, +0x8f820140, 0x3c030001, 0x431025, 0xaf820140, +0x1000002b, 0x0, 0x8f420334, 0x1821, +0x24420001, 0xaf420334, 0x8f420334, 0x306200ff, +0x5040fe7d, 0x3c020800, 0x12600021, 0x9021, +0x8fb100ac, 0x2208021, 0x8e220008, 0x96070018, +0x8fa6006c, 0x8c440000, 0x8c450004, 0x240b0001, +0xafab0010, 0xafbe0014, 0x8f420008, 0xafa20018, +0x8f42010c, 0x40f809, 0x0, 0x1040ffc4, +0x3c050007, 0x96020018, 0x8faa006c, 0x8fab00a4, +0x1425021, 0x16a102b, 0x10400004, 0xafaa006c, +0x8f420148, 0x1425023, 0xafaa006c, 0x26100002, +0x26520001, 0x253102b, 0x1440ffe3, 0x26310004, +0x8fb00074, 0x97b10038, 0x10000035, 0x0, +0x8f4200fc, 0xa2102a, 0x1440001b, 0x24030001, +0x8f83012c, 0x10600013, 0x0, 0x8f820124, +0x431023, 0x22143, 0x58800001, 0x24840040, +0x8f820128, 0x431023, 0x21943, 0x58600001, +0x24630040, 0x64102a, 0x54400001, 0x602021, +0xaf4400fc, 0x8f4200fc, 0xa2102a, 0x14400006, +0x24030001, 0x8f420334, 0x1821, 0x24420001, +0xaf420334, 0x8f420334, 0x306200ff, 0x1040fe46, +0x3c020800, 0x96b1000a, 0x8fb00074, 0x3223ffff, +0x70102b, 0x54400001, 0x608021, 0x8ea40000, +0x8ea50004, 0x240a0001, 0xafaa0010, 0xafbe0014, +0x8f420008, 0x8fa6006c, 0xafa20018, 0x8f42010c, +0x40f809, 0x2003821, 0x1040fe43, 0x3c050007, +0x96a4000e, 0x97ab0096, 0x11600007, 0x809021, +0x934205c4, 0x14400004, 0x0, 0x97aa008e, +0x8b2025, 0xa6aa0016, 0x8fab0084, 0x3c02ffff, +0x1621024, 0x10400003, 0xb1402, 0x34840400, +0xa6a20014, 0x3c021000, 0x2c21024, 0x10400006, +0x0, 0x8fa20040, 0x401821, 0x1021, +0xaea20000, 0xaea30004, 0x8faa0074, 0x560a0073, +0xa6a4000e, 0x34820004, 0xa6a2000e, 0x8fab007c, +0x14b1021, 0xa6a2000a, 0x8f430044, 0x8f4401a0, +0x8f4501a4, 0x34028000, 0xafa20010, 0x8f420044, +0x2a03021, 0x24070020, 0xafa20014, 0x8f42000c, +0x31940, 0x604821, 0xafa20018, 0x8f42010c, +0x4021, 0xa92821, 0xa9182b, 0x882021, +0x40f809, 0x832021, 0x5040fe19, 0xa6b2000e, +0x8f420368, 0xafa00074, 0xa34005c4, 0x2442ffff, +0xaf420368, 0x8faa0064, 0x240b0001, 0x8f420368, +0x154b0006, 0x24020002, 0x8f42035c, 0x2442ffff, +0xaf42035c, 0x1000000c, 0x8f42035c, 0x15420006, +0x0, 0x8f420364, 0x2442ffff, 0xaf420364, +0x10000005, 0x8f420364, 0x8f420360, 0x2442ffff, +0xaf420360, 0x8f420360, 0x8faa005c, 0x8fab0054, +0xad6a0000, 0x8f420044, 0x8f440088, 0x8f430078, +0x24420001, 0x441024, 0x24630001, 0xaf420044, +0xaf430078, 0x8c020240, 0x62182b, 0x14600076, +0x24070008, 0x8f440168, 0x8f45016c, 0x8f430044, +0x8f48000c, 0x8f860120, 0x24020040, 0xafa20010, +0xafa30014, 0xafa80018, 0x8f42010c, 0x40f809, +0x24c6001c, 0x14400011, 0x240b0001, 0x3c010001, +0x370821, 0xa02b40f2, 0x8f820124, 0xafa20010, +0x8f820128, 0x3c040001, 0x24847d7c, 0xafa20014, +0x8f460044, 0x8f870120, 0x3c050009, 0xc002d3b, +0x34a51300, 0x1000000b, 0x0, 0x8f420304, +0x24420001, 0xaf420304, 0x8f420304, 0x8f420044, +0xaf42007c, 0x3c010001, 0x370821, 0xa02040f2, +0xaf400078, 0x8f420318, 0x24420001, 0xaf420318, +0x8f420318, 0x10000048, 0x0, 0xa6b0000a, 0x8f430044, 0x8f4401a0, 0x8f4501a4, 0x34028000, 0xafa20010, 0x8f420044, 0x2a03021, 0x24070020, 0xafa20014, 0x8f42000c, 0x31940, 0x604821, 0xafa20018, 0x8f42010c, 0x4021, 0xa92821, 0xa9182b, 0x882021, 0x40f809, 0x832021, -0x1040fe1f, 0x240a0001, 0xa34a05c4, 0x8fab006c, -0x8faa0064, 0x1705823, 0xafab006c, 0x8fab009c, -0x1505021, 0x16a102b, 0x10400004, 0xafaa0064, -0x8f420148, 0x1425023, 0xafaa0064, 0x8f420368, -0x2442ffff, 0xaf420368, 0x8faa005c, 0x240b0001, -0x8f420368, 0x154b0006, 0x240b0002, 0x8f42035c, +0x1040fdba, 0x240a0001, 0xa34a05c4, 0x8fab0074, +0x8faa006c, 0x1705823, 0xafab0074, 0x8fab00a4, +0x1505021, 0x16a102b, 0x10400004, 0xafaa006c, +0x8f420148, 0x1425023, 0xafaa006c, 0x8f420368, +0x2442ffff, 0xaf420368, 0x8faa0064, 0x240b0001, +0x8f420368, 0x154b0006, 0x24020002, 0x8f42035c, 0x2442ffff, 0xaf42035c, 0x1000000c, 0x8f42035c, -0x114b0006, 0x0, 0x8f420360, 0x2442ffff, +0x11420006, 0x0, 0x8f420360, 0x2442ffff, 0xaf420360, 0x10000005, 0x8f420360, 0x8f420364, -0x2442ffff, 0xaf420364, 0x8f420364, 0x8fab0054, -0x8faa004c, 0xad4b0000, 0x8f420044, 0x8f440088, +0x2442ffff, 0xaf420364, 0x8f420364, 0x8faa005c, +0x8fab0054, 0xad6a0000, 0x8f420044, 0x8f440088, 0x8f430078, 0x24420001, 0x441024, 0x24630001, -0xaf420044, 0xaf430078, 0x8faa006c, 0x1540fe0b, -0x0, 0x8fab006c, 0x1160001e, 0x0, -0x934205c4, 0x10400009, 0x0, 0x8faa0064, -0xaf4a00c4, 0xaf4b00c0, 0x8fab007c, 0xaf4b00c8, -0x8faa0074, 0x1000000e, 0xaf4a00cc, 0x97ab008e, -0x1160000b, 0x34038100, 0x8fa20020, 0x8c46000c, -0xa443000c, 0x97aa0086, 0x8c440004, 0x8c450008, -0xa44a000e, 0xac440000, 0xac450004, 0xac460008, -0x8f42034c, 0x24420001, 0xaf42034c, 0x10000010, -0x8f42034c, 0x8fab007c, 0x3164ffff, 0x2484fffc, -0x801821, 0x8f440250, 0x8f450254, 0x8f460118, -0x1021, 0xa32821, 0xa3382b, 0x822021, -0x872021, 0xaf440250, 0xc0f809, 0xaf450254, -0x8fbf00c8, 0x8fbe00c4, 0x8fb500c0, 0x8fb300bc, -0x8fb200b8, 0x8fb100b4, 0x8fb000b0, 0x3e00008, -0x27bd00d0, 0x3e00008, 0x0, 0x27bdff38, -0x240b0001, 0xafbf00c0, 0xafbe00bc, 0xafb500b8, -0xafb300b4, 0xafb200b0, 0xafb100ac, 0xafb000a8, -0xa3a00087, 0xafa00044, 0xafab005c, 0x934205c4, -0xa7a00076, 0x10400007, 0xa7a0007e, 0x8f4c00c0, -0xafac0064, 0x8f4b00c8, 0x8f5e00c4, 0x10000130, -0xafab006c, 0x8f420114, 0x40f809, 0x0, -0x403021, 0x10c002a1, 0x0, 0x8cc20000, +0xaf420044, 0xaf430078, 0x8fab0074, 0x1560fdba, +0x0, 0x8faa0074, 0x1140001f, 0x0, +0x934205c4, 0x10400009, 0x0, 0x8fab006c, +0xaf4b00c4, 0xaf4a00c0, 0x8faa0084, 0xaf4a00c8, +0x8fab007c, 0x1000000e, 0xaf4b00cc, 0x97aa0096, +0x1140000b, 0x34038100, 0x8fa20020, 0x8c46000c, +0xa443000c, 0x97ab008e, 0x8c440004, 0x8c450008, +0xa44b000e, 0xac440000, 0xac450004, 0xac460008, +0x8f42034c, 0x24420001, 0xaf42034c, 0x8f42034c, +0x10000011, 0x0, 0x8faa0084, 0x3144ffff, +0x2484fffc, 0x801821, 0x8f440250, 0x8f450254, +0x8f460118, 0x1021, 0xa32821, 0xa3382b, +0x822021, 0x872021, 0xaf440250, 0xaf450254, +0xc0f809, 0x0, 0x8fbf00d0, 0x8fbe00cc, +0x8fb500c8, 0x8fb300c4, 0x8fb200c0, 0x8fb100bc, +0x8fb000b8, 0x3e00008, 0x27bd00d8, 0x3e00008, +0x0, 0x27bdff30, 0x240b0001, 0xafbf00c8, +0xafbe00c4, 0xafb500c0, 0xafb300bc, 0xafb200b8, +0xafb100b4, 0xafb000b0, 0xa3a0008f, 0xafa0004c, +0xafab0064, 0xa7a0007e, 0xafa00040, 0x934205c4, +0x8821, 0x10400007, 0xa7a00086, 0x8f4c00c0, +0xafac006c, 0x8f4b00c8, 0x8f5e00c4, 0x100001a1, +0xafab0074, 0x8f420114, 0x40f809, 0x0, +0x403021, 0x10c00365, 0x0, 0x8cc20000, 0x8cc30004, 0xafa20020, 0xafa30024, 0x8fac0024, -0x8fbe0020, 0x3182ffff, 0x2442fffc, 0xafa20064, -0x3c020006, 0x2c21024, 0x14400015, 0xafac006c, +0x8fbe0020, 0x3182ffff, 0x2442fffc, 0xafa2006c, +0x3c020006, 0x2c21024, 0x14400015, 0xafac0074, 0x93c20000, 0x30420001, 0x10400011, 0x2402ffff, 0x8fc30000, 0x14620004, 0x3402ffff, 0x97c30004, -0x1062000b, 0x0, 0xc0024ba, 0x3c02021, +0x1062000b, 0x0, 0xc0025dd, 0x3c02021, 0x304200ff, 0x14400006, 0x0, 0x8f420118, -0x40f809, 0x0, 0x10000280, 0x0, +0x40f809, 0x0, 0x10000344, 0x0, 0x8fa20024, 0x3c03ffbf, 0x3463ffff, 0x431024, 0x3c03ffff, 0x431824, 0x14600003, 0xafa20024, 0x10000040, 0x8021, 0x3c020080, 0x621024, @@ -2500,180 +2752,241 @@ 0x8f4201c0, 0x24420001, 0xaf4201c0, 0x8f4201c0, 0x3c020020, 0x621024, 0x10400006, 0x24100001, 0x8f420388, 0x24420001, 0xaf420388, 0x8f420388, -0x24100001, 0x8c020260, 0x8fab0064, 0x4b102b, +0x24100001, 0x8c020260, 0x8fab006c, 0x4b102b, 0x10400015, 0x320200ff, 0x8f4201e8, 0x24420001, -0xaf4201e8, 0x8f4201e8, 0x8fac006c, 0x8f8200e0, -0x358c0100, 0xafac006c, 0xafa20010, 0x8f8200e4, -0x24100001, 0x3c040001, 0x24846960, 0xafa20014, -0x8fa60020, 0x8fa70024, 0x3c050007, 0xc002b37, -0x34a53600, 0x320200ff, 0x10400010, 0x3c020080, -0x2c21024, 0x1440000e, 0x32c20400, 0x8fab006c, +0xaf4201e8, 0x8f4201e8, 0x8fac0074, 0x8f8200e0, +0x358c0100, 0xafac0074, 0xafa20010, 0x8f8200e4, +0x24100001, 0x3c040001, 0x24847da0, 0xafa20014, +0x8fa60020, 0x8fa70024, 0x3c050007, 0xc002d3b, +0x34a53600, 0x320200ff, 0x10400011, 0x3c020080, +0x2c21024, 0x1440000f, 0x32c20400, 0x8fab0074, 0x3c020080, 0x34420100, 0x1621024, 0x10400005, 0x0, 0x8f42020c, 0x24420001, 0xaf42020c, -0x8f42020c, 0x10000202, 0x8fa30064, 0x32c20400, -0x10400012, 0x34028100, 0x97c3000c, 0x1462000f, -0x0, 0x240c0200, 0xa7ac0076, 0x97c2000e, -0x8fc30008, 0x8fc40004, 0x8fab0064, 0x8fc50000, -0x256bfffc, 0xafab0064, 0xa7a2007e, 0xafc3000c, -0xafc40008, 0xafc50004, 0x27de0004, 0x8fa70064, -0x320200ff, 0x14400034, 0x3c020100, 0x97c4000c, -0x2c8305dd, 0x38828870, 0x2c420001, 0x621825, -0x10600015, 0x2821, 0x32c20800, 0x10400015, +0x8f42020c, 0x8fa3006c, 0x100002c4, 0x0, +0x32c20400, 0x10400012, 0x34028100, 0x97c3000c, +0x1462000f, 0x0, 0x240c0200, 0xa7ac007e, +0x97c2000e, 0x8fc30008, 0x8fc40004, 0x8fab006c, +0x8fc50000, 0x256bfffc, 0xafab006c, 0xa7a20086, +0xafc3000c, 0xafc40008, 0xafc50004, 0x27de0004, +0x8fa7006c, 0x320200ff, 0x14400033, 0x3c020100, +0x97c4000c, 0x2c8305dd, 0x38828870, 0x2c420001, +0x621825, 0x10600014, 0x32c20800, 0x10400015, 0x24020800, 0x97c30014, 0x14620012, 0x3402aaaa, 0x97c3000e, 0x14620007, 0x2021, 0x97c30010, 0x24020300, 0x14620004, 0x801021, 0x97c20012, -0x2c440001, 0x801021, 0x54400006, 0x24050016, +0x2c440001, 0x801021, 0x54400006, 0x24110016, 0x10000004, 0x0, 0x24020800, 0x50820001, -0x2405000e, 0x10a00013, 0x3c52021, 0x24830009, +0x2411000e, 0x12200013, 0x3d12021, 0x24830009, 0x3c02001f, 0x3442ffff, 0x43102b, 0x10400003, 0x0, 0x8f420148, 0x621823, 0x90620000, 0x38430006, 0x2c630001, 0x38420011, 0x2c420001, 0x621825, 0x10600004, 0x3c020100, 0x94820002, -0x453821, 0x3c020100, 0x2c21024, 0x5040000e, -0xafa70064, 0x8fac0064, 0x10ec0008, 0x3c050007, -0x3c040001, 0x248469c8, 0x8fa60064, 0x34a54000, -0xafa00010, 0xc002b37, 0xafa00014, 0x8fab0064, -0x256b0004, 0xafab0064, 0x8f420080, 0x8fac0064, -0x4c102b, 0x1040002c, 0x32c28000, 0x10400034, -0x240b0003, 0x32c21000, 0x10400031, 0xafab005c, -0x1000002e, 0x240c0004, 0x8f420350, 0x2403ffbf, -0x283a024, 0x24420001, 0xaf420350, 0x10000173, -0x8f420350, 0x3c020800, 0x2c2b025, 0x2402ffbf, -0x282a024, 0x8f830128, 0x3c040001, 0x24846990, -0x26620001, 0xafa20014, 0xafa30010, 0x8f860120, -0x8f870124, 0x3c050007, 0xc002b37, 0x34a55300, -0x10000162, 0x0, 0x8ea20000, 0x8ea30004, -0x3c040001, 0x248469a8, 0xafb00010, 0xafb10014, -0x8ea70018, 0x34a55900, 0xc002b37, 0x603021, -0x10000156, 0x0, 0x8f420084, 0x8fab0064, -0x4b102b, 0x14400007, 0x3c020001, 0x2c21024, -0x10400004, 0x0, 0x240c0002, 0xafac005c, -0x8fab0064, 0x11600166, 0x27ac0020, 0xafac008c, -0x8fab005c, 0x240c0001, 0x556c0021, 0x240c0002, -0x8f430054, 0x8f420050, 0x1062000b, 0x274b0054, -0x8f510054, 0x3403ecc0, 0xafab004c, 0x26220001, -0x304201ff, 0xafa20054, 0x111140, 0x431021, -0x1000006b, 0x2e2a821, 0x8f420044, 0x8fac0064, -0x3c040001, 0x2484696c, 0xafac0014, 0xafa20010, -0x8f460054, 0x8f470050, 0x3c050007, 0xc002b37, -0x34a54300, 0x8f430350, 0x2402ffbf, 0x282a024, -0x24630001, 0xaf430350, 0x10000124, 0x8f420350, -0x156c001d, 0x0, 0x8f430074, 0x8f420070, -0x1062000a, 0x274b0074, 0x8f510074, 0xafab004c, -0x26220001, 0x304203ff, 0xafa20054, 0x111140, -0x24426cc0, 0x1000004a, 0x2e2a821, 0x8f420044, -0x8fac0064, 0x3c040001, 0x24846978, 0x3c050007, -0xafac0014, 0xafa20010, 0x8f460074, 0x8f470070, -0x34a54500, 0x240b0001, 0xc002b37, 0xafab005c, -0x1000ffc3, 0x0, 0x8f430064, 0x8f420060, -0x1062001a, 0x274c0064, 0x8f510064, 0x8fab005c, -0xafac004c, 0x26220001, 0x304200ff, 0xafa20054, -0x24020004, 0x1562000e, 0x111140, 0x111180, -0x24420cc0, 0x2e21021, 0xafa20044, 0x9442002a, -0x8fac0044, 0x8fab0064, 0x4b102b, 0x10400024, -0x25950020, 0x240c0001, 0x10000021, 0xa3ac0087, -0x24424cc0, 0x1000001e, 0x2e2a821, 0x8f420044, -0x8fab0064, 0x3c040001, 0x24846984, 0xafab0014, -0xafa20010, 0x8f460064, 0x8f470060, 0x3c050007, -0xc002b37, 0x34a54800, 0x3c020008, 0x2c21024, -0x1440ff61, 0x0, 0x8f420370, 0x240c0001, -0xafac005c, 0x24420001, 0xaf420370, 0x1000ff90, -0x8f420370, 0x27a30036, 0x131040, 0x621821, -0x94620000, 0x441021, 0x1000001f, 0xa4620000, -0xaebe0018, 0x93a20087, 0x10400084, 0x9821, -0x8fab0044, 0x8fa40064, 0x8fa3008c, 0x25620020, -0xafa20028, 0x25620008, 0xafa20030, 0x25620010, -0xafab002c, 0xafa20034, 0x9562002a, 0xa7a20038, -0x95620018, 0xa7a2003a, 0x9562001a, 0xa7a2003c, -0x9562001c, 0xa7a2003e, 0x94620018, 0x24630002, -0x822023, 0x1880ffdf, 0x26730001, 0x2e620004, -0x1440fff9, 0x0, 0x8f4200fc, 0x262102a, -0x14400030, 0x24030001, 0x8f83012c, 0x10600028, +0x513821, 0x3c020100, 0x2c21024, 0x5040000e, +0xafa7006c, 0x8fac006c, 0x10ec0008, 0x3c050007, +0x3c040001, 0x24847e10, 0x8fa6006c, 0x34a54000, +0xafa00010, 0xc002d3b, 0xafa00014, 0x8fab006c, +0x256b0004, 0xafab006c, 0x8f420080, 0x8fac006c, +0x4c102b, 0x1040009d, 0x32c28000, 0x104000a5, +0x32c21000, 0x10400072, 0x240b0004, 0x3c021000, +0x2c21024, 0x1040009f, 0xafab0064, 0x1220009d, +0x1911023, 0x2c420014, 0x1440009a, 0x3d12821, +0x24a30006, 0x90a20000, 0x3c07001f, 0x34e7ffff, +0x3042000f, 0x24080, 0xe3102b, 0x10400003, +0x0, 0x8f420148, 0x621823, 0x94620000, +0x30421fff, 0x10400003, 0x2281021, 0x10000089, +0xafa20040, 0x24a30009, 0xe3102b, 0x10400003, +0x0, 0x8f420148, 0x621823, 0x90630000, +0x24020006, 0x1462002b, 0x24020011, 0x94a20002, +0x2c420028, 0x1440007b, 0xa83021, 0xe6102b, +0x10400004, 0x24c3000c, 0x8f420148, 0xc23023, +0x24c3000c, 0xe3102b, 0x10400003, 0x0, +0x8f420148, 0x621823, 0x90640000, 0x94a30002, +0x308200f0, 0x22082, 0x2281021, 0x442021, +0x2c6300b8, 0x14600067, 0xafa40040, 0x94c20000, +0x38430801, 0x2c630001, 0x3842639d, 0x2c420001, +0x621825, 0x14600009, 0x24820090, 0x94c20002, +0x38430801, 0x2c630001, 0x3842639d, 0x2c420001, +0x621825, 0x10600057, 0x24820090, 0x10000055, +0xafa20040, 0x14620053, 0x0, 0x94a20002, +0x2c42001c, 0x1440004f, 0x2283021, 0x94a30002, +0x24c20008, 0x2c63009c, 0x1460004a, 0xafa20040, +0xa82021, 0xe4102b, 0x10400003, 0x0, +0x8f420148, 0x822023, 0x94820000, 0x38430801, +0x2c630001, 0x3842639d, 0x2c420001, 0x621825, +0x14600009, 0x24c20088, 0x94820002, 0x38430801, +0x2c630001, 0x3842639d, 0x2c420001, 0x621825, +0x10600034, 0x24c20088, 0x10000032, 0xafa20040, +0x1000002f, 0x240c0003, 0x8f420350, 0x2403ffbf, +0x283a024, 0x24420001, 0xaf420350, 0x8f420350, +0x100001c4, 0x0, 0x3c020800, 0x2c2b025, +0x2402ffbf, 0x282a024, 0x8f830128, 0x3c040001, +0x24847dd8, 0x26620001, 0xafa20014, 0xafa30010, +0x8f860120, 0x8f870124, 0x3c050007, 0xc002d3b, +0x34a55300, 0x100001b3, 0x0, 0x8ea20000, +0x8ea30004, 0x3c040001, 0x24847df0, 0xafb00010, +0xafb10014, 0x8ea70018, 0x34a55900, 0xc002d3b, +0x603021, 0x100001a7, 0x0, 0x8f420084, +0x8fab006c, 0x4b102b, 0x14400007, 0x3c020001, +0x2c21024, 0x10400004, 0x0, 0x240c0002, +0xafac0064, 0x8fab006c, 0x116001b8, 0x27ac0020, +0xafac0094, 0x8fab0064, 0x240c0001, 0x556c0022, +0x240c0002, 0x8f430054, 0x8f420050, 0x1062000b, +0x274b0054, 0x8f510054, 0x3403ecc0, 0xafab0054, +0x26220001, 0x304201ff, 0xafa2005c, 0x111140, +0x431021, 0x10000077, 0x2e2a821, 0x8f420044, +0x8fac006c, 0x3c040001, 0x24847dac, 0xafac0014, +0xafa20010, 0x8f460054, 0x8f470050, 0x3c050007, +0xc002d3b, 0x34a54300, 0x8f430350, 0x2402ffbf, +0x282a024, 0x24630001, 0xaf430350, 0x8f420350, +0x10000174, 0x0, 0x156c001d, 0x0, +0x8f430074, 0x8f420070, 0x1062000a, 0x274b0074, +0x8f510074, 0xafab0054, 0x26220001, 0x304203ff, +0xafa2005c, 0x111140, 0x24426cc0, 0x10000055, +0x2e2a821, 0x8f420044, 0x8fac006c, 0x3c040001, +0x24847db8, 0x3c050007, 0xafac0014, 0xafa20010, +0x8f460074, 0x8f470070, 0x34a54500, 0x240b0001, +0xc002d3b, 0xafab0064, 0x1000ffc2, 0x0, +0x8f430064, 0x8f420060, 0x1062002b, 0x274c0064, +0x8f510064, 0x8fab0064, 0xafac0054, 0x26220001, +0x304200ff, 0xafa2005c, 0x24020004, 0x1562001f, +0x111140, 0x111180, 0x24420cc0, 0x2e21021, +0xafa2004c, 0x24550020, 0x3c021000, 0x2c21024, +0x1040000e, 0x0, 0x8fac004c, 0x8fab006c, +0x9582002a, 0x4b102b, 0x54400006, 0x240c0001, +0x8fa20040, 0x50400028, 0xaebe0018, 0x104b0025, +0x240c0001, 0x10000023, 0xa3ac008f, 0x8fab004c, +0x8fac006c, 0x9562002a, 0x4c102b, 0x1040001d, +0x240b0001, 0x1000001b, 0xa3ab008f, 0x24424cc0, +0x10000018, 0x2e2a821, 0x8f420044, 0x8fac006c, +0x3c040001, 0x24847dc4, 0xafac0014, 0xafa20010, +0x8f460064, 0x8f470060, 0x3c050007, 0xc002d3b, +0x34a54800, 0x3c020008, 0x2c21024, 0x1440ff4e, +0x0, 0x8f420370, 0x240b0001, 0xafab0064, +0x24420001, 0xaf420370, 0x8f420370, 0x1000ff7d, +0x0, 0xaebe0018, 0x93a2008f, 0x104000bf, +0x0, 0x8fac004c, 0x8fa40040, 0x25820020, +0xafa20028, 0x25820008, 0xafa20030, 0x25820010, +0xafac002c, 0x1080000e, 0xafa20034, 0x9583002a, +0x83102b, 0x54400001, 0x801821, 0x1000000b, +0xa7a30038, 0x27a30036, 0x131040, 0x621821, +0x94620000, 0x441021, 0x10000016, 0xa4620000, +0x8fab004c, 0x9562002a, 0xa7a20038, 0x8fac004c, +0x8fa4006c, 0x8fa30094, 0x95820018, 0xa7a2003a, +0x9582001a, 0xa7a2003c, 0x9582001c, 0x9821, +0xa7a2003e, 0x94620018, 0x24630002, 0x822023, +0x1880ffe8, 0x26730001, 0x2e620004, 0x1440fff9, +0x0, 0x18800014, 0x240207db, 0x3c040001, +0x24847d84, 0xafa20010, 0xafa00014, 0x8f860144, +0x3c070001, 0x24e77dd0, 0xc002d3b, 0x3405dead, +0x8f82011c, 0x34420002, 0xaf82011c, 0x8f820220, +0x34420004, 0xaf820220, 0x8f820140, 0x3c030001, +0x431025, 0xaf820140, 0x8f4200fc, 0x262102a, +0x14400044, 0x24030001, 0x8f83012c, 0x1060003c, 0x0, 0x8f820124, 0x431023, 0x22143, 0x58800001, 0x24840040, 0x8f820128, 0x431023, 0x21943, 0x58600001, 0x24630040, 0x64102a, 0x54400001, 0x602021, 0xaf4400fc, 0x8f4200fc, -0x262102a, 0x10400016, 0x24030001, 0x1000001a, -0x306200ff, 0x8fac008c, 0x101040, 0x4c1021, -0x94470018, 0x101080, 0x4c1021, 0xafbe0010, -0x8c420008, 0x3c040001, 0x2484699c, 0x3c050007, +0x262102a, 0x1040002a, 0x24030001, 0x1000002e, +0x306200ff, 0x8fab0094, 0x101040, 0x4b1021, +0x94470018, 0x101080, 0x4b1021, 0xafbe0010, +0x8c420008, 0x3c040001, 0x24847de4, 0x3c050007, 0x8c430004, 0x8c420000, 0x34a55500, 0x2003021, -0xc002b37, 0xafa30014, 0x10000039, 0x0, +0xc002d3b, 0xafa30014, 0x3c040001, 0x24847d84, +0x2402080d, 0xafa20010, 0xafa00014, 0x8f860144, +0x3c070001, 0x24e77dd0, 0xc002d3b, 0x3405dead, +0x8f82011c, 0x34420002, 0xaf82011c, 0x8f820220, +0x34420004, 0xaf820220, 0x8f820140, 0x3c030001, +0x431025, 0xaf820140, 0x10000039, 0x0, 0x8f420334, 0x1821, 0x24420001, 0xaf420334, -0x8f420334, 0x306200ff, 0x1040ff06, 0x8021, +0x8f420334, 0x306200ff, 0x1040febf, 0x8021, 0x8f430008, 0x2402fbff, 0x1260002d, 0x625024, -0x3c0b4000, 0x22b4025, 0x8fb1008c, 0x2669ffff, +0x3c0c4000, 0x22c4025, 0x8fb10094, 0x2669ffff, 0x2209021, 0x8e420008, 0x96270018, 0x8c440000, -0x8c450004, 0x56090004, 0x240b0001, 0x240c0002, -0x10000002, 0xafac0010, 0xafab0010, 0x16000004, +0x8c450004, 0x56090004, 0x240c0001, 0x240b0002, +0x10000002, 0xafab0010, 0xafac0010, 0x16000004, 0xafa80014, 0x8f420008, 0x10000002, 0xafa20018, -0xafaa0018, 0x8f42010c, 0x3c03021, 0xafa80098, -0xafa9009c, 0x40f809, 0xafaa00a0, 0x8fa80098, -0x8fa9009c, 0x8faa00a0, 0x1040ffc2, 0x3c02001f, +0xafaa0018, 0x8f42010c, 0x3c03021, 0xafa800a0, +0xafa900a4, 0x40f809, 0xafaa00a8, 0x8fa800a0, +0x8fa900a4, 0x8faa00a8, 0x1040ffae, 0x3c02001f, 0x96230018, 0x3442ffff, 0x3c3f021, 0x5e102b, 0x10400003, 0x26310002, 0x8f420148, 0x3c2f023, 0x26100001, 0x213102b, 0x1440ffda, 0x26520004, -0x8fb00064, 0x1000001a, 0x0, 0x96a3000a, -0x8fb00064, 0x70102b, 0x54400001, 0x608021, -0x8ea40000, 0x8ea50004, 0x8fab005c, 0x240c0002, -0xafac0010, 0x934305c4, 0xb1700, 0x10600003, +0x8fb0006c, 0x1000001a, 0x0, 0x96a3000a, +0x8fb0006c, 0x70102b, 0x54400001, 0x608021, +0x8ea40000, 0x8ea50004, 0x8fac0064, 0x240b0002, +0xafab0010, 0x934305c4, 0xc1700, 0x10600003, 0x2223025, 0x3c020800, 0xc23025, 0xafa60014, 0x8f420008, 0xafa20018, 0x8f42010c, 0x3c03021, -0x40f809, 0x2003821, 0x1040fecb, 0x3c050007, -0x97ac0076, 0x11800007, 0x96a3000e, 0x934205c4, -0x14400004, 0x0, 0x97ab007e, 0x6c1825, -0xa6ab0016, 0x8fac006c, 0x3c02ffff, 0x1821024, -0x10400003, 0xc1402, 0x34630400, 0xa6a20014, -0xa6b0000a, 0x8fab0064, 0x560b0006, 0x3d0f021, -0x34620004, 0xafa00064, 0xa6a2000e, 0x1000000d, -0xa34005c4, 0x8fac0064, 0x3c02001f, 0x3442ffff, -0x5e102b, 0x1906023, 0xafac0064, 0xa6a3000e, -0x240b0001, 0x10400003, 0xa34b05c4, 0x8f420148, -0x3c2f023, 0x8fab0054, 0x8fac004c, 0xad8b0000, -0x8fac0064, 0x1580feba, 0x0, 0x8fab0064, -0x1160001b, 0x0, 0x934205c4, 0x10400006, -0x0, 0xaf5e00c4, 0xaf4b00c0, 0x8fac006c, -0x1000000e, 0xaf4c00c8, 0x97ab0076, 0x1160000b, -0x34038100, 0x8fa20020, 0x8c46000c, 0xa443000c, -0x97ac007e, 0x8c440004, 0x8c450008, 0xa44c000e, -0xac440000, 0xac450004, 0xac460008, 0x8f42034c, -0x24420001, 0xaf42034c, 0x10000010, 0x8f42034c, -0x8fab006c, 0x3164ffff, 0x2484fffc, 0x801821, -0x8f440250, 0x8f450254, 0x8f460118, 0x1021, -0xa32821, 0xa3382b, 0x822021, 0x872021, -0xaf440250, 0xc0f809, 0xaf450254, 0x8fbf00c0, -0x8fbe00bc, 0x8fb500b8, 0x8fb300b4, 0x8fb200b0, -0x8fb100ac, 0x8fb000a8, 0x3e00008, 0x27bd00c8, -0x3e00008, 0x0, 0x27bdffd8, 0xafbf0024, -0xafb00020, 0x8f43004c, 0x8f420048, 0x10620034, -0x0, 0x8f430048, 0x8f42004c, 0x622023, -0x4820001, 0x24840200, 0x8f430054, 0x8f42004c, -0x43102b, 0x14400004, 0x24020200, 0x8f43004c, -0x10000005, 0x431023, 0x8f420054, 0x8f43004c, -0x431023, 0x2442ffff, 0x405021, 0x8a102a, -0x54400001, 0x805021, 0x8f49004c, 0x8f48004c, -0x8f440188, 0x8f45018c, 0x8f46004c, 0x24071000, -0xafa70010, 0x84140, 0x1001821, 0x12a4821, -0x313001ff, 0xafb00014, 0x8f470014, 0x1021, -0x63140, 0xafa70018, 0xa32821, 0xa3382b, -0x822021, 0x872021, 0x3402ecc0, 0xc23021, -0x8f420108, 0x2e63021, 0x40f809, 0xa3940, -0x54400001, 0xaf50004c, 0x8f43004c, 0x8f420048, -0x14620018, 0x0, 0x8f420000, 0x10400007, -0x0, 0xaf80004c, 0x8f82004c, 0x1040fffd, -0x0, 0x10000005, 0x0, 0xaf800048, -0x8f820048, 0x1040fffd, 0x0, 0x8f820060, -0x2403fdff, 0x431024, 0xaf820060, 0x8f420000, -0x10400003, 0x0, 0x10000002, 0xaf80004c, -0xaf800048, 0x8fbf0024, 0x8fb00020, 0x3e00008, -0x27bd0028, 0x3e00008, 0x0, 0x27bdffd8, -0xafbf0024, 0xafb00020, 0x8f43005c, 0x8f420058, -0x10620049, 0x0, 0x8f430058, 0x8f42005c, -0x622023, 0x4820001, 0x24840100, 0x8f430064, -0x8f42005c, 0x43102b, 0x14400004, 0x24020100, -0x8f43005c, 0x10000005, 0x431023, 0x8f420064, -0x8f43005c, 0x431023, 0x2442ffff, 0x403821, -0x87102a, 0x54400001, 0x803821, 0x8f42005c, +0x40f809, 0x2003821, 0x1040fe84, 0x3c050007, +0x97ab007e, 0x96a3000e, 0x11600007, 0x0, +0x934205c4, 0x14400004, 0x0, 0x97ac0086, +0x6b1825, 0xa6ac0016, 0x8fab0074, 0x3c02ffff, +0x1621024, 0x10400003, 0xb1402, 0x34630400, +0xa6a20014, 0xa6b0000a, 0x8fac006c, 0x560c0006, +0x3d0f021, 0x34620004, 0xafa0006c, 0xa6a2000e, +0x1000000d, 0xa34005c4, 0x8fab006c, 0x3c02001f, +0x3442ffff, 0x5e102b, 0x1705823, 0xafab006c, +0xa6a3000e, 0x240c0001, 0x10400003, 0xa34c05c4, +0x8f420148, 0x3c2f023, 0x3c021000, 0x2c21024, +0x10400006, 0x0, 0x8fa20040, 0x401821, +0x1021, 0xaea20000, 0xaea30004, 0x8fac005c, +0x8fab0054, 0xad6c0000, 0x8fab006c, 0x1560fe69, +0x0, 0x8fac006c, 0x1180001c, 0x0, +0x934205c4, 0x10400006, 0x0, 0xaf5e00c4, +0xaf4c00c0, 0x8fab0074, 0x1000000e, 0xaf4b00c8, +0x97ac007e, 0x1180000b, 0x34038100, 0x8fa20020, +0x8c46000c, 0xa443000c, 0x97ab0086, 0x8c440004, +0x8c450008, 0xa44b000e, 0xac440000, 0xac450004, +0xac460008, 0x8f42034c, 0x24420001, 0xaf42034c, +0x8f42034c, 0x10000011, 0x0, 0x8fac0074, +0x3184ffff, 0x2484fffc, 0x801821, 0x8f440250, +0x8f450254, 0x8f460118, 0x1021, 0xa32821, +0xa3382b, 0x822021, 0x872021, 0xaf440250, +0xaf450254, 0xc0f809, 0x0, 0x8fbf00c8, +0x8fbe00c4, 0x8fb500c0, 0x8fb300bc, 0x8fb200b8, +0x8fb100b4, 0x8fb000b0, 0x3e00008, 0x27bd00d0, +0x3e00008, 0x0, 0x27bdffd0, 0xafbf0028, +0xafb10024, 0xafb00020, 0x8f43004c, 0x8f420048, +0x1062004a, 0x0, 0x8f430048, 0x8f42004c, +0x628823, 0x6220001, 0x26310200, 0x8f430054, +0x8f42004c, 0x43102b, 0x14400004, 0x24020200, +0x8f43004c, 0x10000005, 0x438023, 0x8f420054, +0x8f43004c, 0x431023, 0x2450ffff, 0x16000016, +0x2005821, 0x3c040001, 0x24847d84, 0x240208a1, +0xafa20010, 0xafa00014, 0x8f860144, 0x3c070001, +0x24e77dd0, 0xc002d3b, 0x3405dead, 0x8f82011c, +0x34420002, 0xaf82011c, 0x8f820220, 0x34420004, +0xaf820220, 0x8f820140, 0x3c030001, 0x431025, +0xaf820140, 0x2005821, 0x22b102a, 0x54400001, +0x2205821, 0x8f4a004c, 0x8f49004c, 0x8f440188, +0x8f45018c, 0x8f46004c, 0xb3940, 0x24081000, +0xafa80010, 0x94940, 0x1201821, 0x1021, +0x14b5021, 0x315001ff, 0xafb00014, 0x8f480014, +0xa32821, 0xa3482b, 0x822021, 0x892021, +0x63140, 0x3402ecc0, 0xafa80018, 0x8f430108, +0xc23021, 0x60f809, 0x2e63021, 0x54400001, +0xaf50004c, 0x8f43004c, 0x8f420048, 0x14620019, +0x0, 0x8f420000, 0x10400007, 0x0, +0xaf80004c, 0x8f82004c, 0x1040fffd, 0x0, +0x10000005, 0x0, 0xaf800048, 0x8f820048, +0x1040fffd, 0x0, 0x8f820060, 0x2403fdff, +0x431024, 0xaf820060, 0x8f420000, 0x10400004, +0x0, 0xaf80004c, 0x10000002, 0x0, +0xaf800048, 0x8fbf0028, 0x8fb10024, 0x8fb00020, +0x3e00008, 0x27bd0030, 0x3e00008, 0x0, +0x27bdffd0, 0xafbf0028, 0xafb10024, 0xafb00020, +0x8f43005c, 0x8f420058, 0x1062005f, 0x0, +0x8f430058, 0x8f42005c, 0x628823, 0x6220001, +0x26310100, 0x8f430064, 0x8f42005c, 0x43102b, +0x14400004, 0x24020100, 0x8f43005c, 0x10000005, +0x438023, 0x8f420064, 0x8f43005c, 0x431023, +0x2450ffff, 0x16000016, 0x2003821, 0x3c040001, +0x24847d84, 0x240208fb, 0xafa20010, 0xafa00014, +0x8f860144, 0x3c070001, 0x24e77dd0, 0xc002d3b, +0x3405dead, 0x8f82011c, 0x34420002, 0xaf82011c, +0x8f820220, 0x34420004, 0xaf820220, 0x8f820140, +0x3c030001, 0x431025, 0xaf820140, 0x2003821, +0x227102a, 0x54400001, 0x2203821, 0x8f42005c, 0x471021, 0x305000ff, 0x32c21000, 0x10400015, 0x24082000, 0x8f49005c, 0x8f440190, 0x8f450194, 0x8f46005c, 0x73980, 0xafa80010, 0xafb00014, @@ -2686,75 +2999,96 @@ 0xa32821, 0xa3482b, 0x822021, 0x892021, 0x63140, 0xafa80018, 0x8f420108, 0x24c64cc0, 0x40f809, 0x2e63021, 0x54400001, 0xaf50005c, -0x8f43005c, 0x8f420058, 0x14620018, 0x0, +0x8f43005c, 0x8f420058, 0x14620019, 0x0, 0x8f420000, 0x10400007, 0x0, 0xaf80004c, 0x8f82004c, 0x1040fffd, 0x0, 0x10000005, 0x0, 0xaf800048, 0x8f820048, 0x1040fffd, 0x0, 0x8f820060, 0x2403feff, 0x431024, -0xaf820060, 0x8f420000, 0x10400003, 0x0, -0x10000002, 0xaf80004c, 0xaf800048, 0x8fbf0024, -0x8fb00020, 0x3e00008, 0x27bd0028, 0x3e00008, -0x0, 0x27bdffd8, 0xafbf0024, 0xafb00020, -0x8f43006c, 0x8f420068, 0x10620033, 0x0, -0x8f430068, 0x8f42006c, 0x622023, 0x4820001, -0x24840400, 0x8f430074, 0x8f42006c, 0x43102b, -0x14400004, 0x24020400, 0x8f43006c, 0x10000005, -0x431023, 0x8f420074, 0x8f43006c, 0x431023, -0x2442ffff, 0x405021, 0x8a102a, 0x54400001, -0x805021, 0x8f49006c, 0x8f48006c, 0x8f440198, -0x8f45019c, 0x8f46006c, 0x24074000, 0xafa70010, -0x84140, 0x1001821, 0x12a4821, 0x313003ff, -0xafb00014, 0x8f470014, 0x1021, 0x63140, -0x24c66cc0, 0xafa70018, 0xa32821, 0xa3382b, -0x822021, 0x872021, 0x8f420108, 0x2e63021, -0x40f809, 0xa3940, 0x54400001, 0xaf50006c, -0x8f43006c, 0x8f420068, 0x14620018, 0x0, -0x8f420000, 0x10400007, 0x0, 0xaf80004c, -0x8f82004c, 0x1040fffd, 0x0, 0x10000005, -0x0, 0xaf800048, 0x8f820048, 0x1040fffd, -0x0, 0x8f820060, 0x2403f7ff, 0x431024, -0xaf820060, 0x8f420000, 0x10400003, 0x0, -0x10000002, 0xaf80004c, 0xaf800048, 0x8fbf0024, -0x8fb00020, 0x3e00008, 0x27bd0028, 0x3e00008, -0x0, 0x8f4200fc, 0x3c030001, 0x8f4400f8, -0x346330c8, 0x24420001, 0xaf4200fc, 0x8f850128, -0x2e31021, 0x54820004, 0x24820008, 0x3c020001, -0x34422ec8, 0x2e21021, 0x401821, 0xaf4300f8, -0xac600000, 0x8f4200f4, 0x14620004, 0x3c020001, -0x24a20020, 0x1000000f, 0xaf820128, 0x8f4300f8, -0x344230c8, 0x2e21021, 0x54620004, 0x24620008, -0x3c020001, 0x34422ec8, 0x2e21021, 0x401821, -0x8c620004, 0x21140, 0xa21021, 0xaf820128, -0xac600000, 0x8ca30018, 0x30620070, 0x1040002d, +0xaf820060, 0x8f420000, 0x10400004, 0x0, +0xaf80004c, 0x10000002, 0x0, 0xaf800048, +0x8fbf0028, 0x8fb10024, 0x8fb00020, 0x3e00008, +0x27bd0030, 0x3e00008, 0x0, 0x27bdffd0, +0xafbf0028, 0xafb10024, 0xafb00020, 0x8f43006c, +0x8f420068, 0x10620049, 0x0, 0x8f430068, +0x8f42006c, 0x628823, 0x6220001, 0x26310400, +0x8f430074, 0x8f42006c, 0x43102b, 0x14400004, +0x24020400, 0x8f43006c, 0x10000005, 0x438023, +0x8f420074, 0x8f43006c, 0x431023, 0x2450ffff, +0x16000016, 0x2005821, 0x3c040001, 0x24847d84, +0x24020964, 0xafa20010, 0xafa00014, 0x8f860144, +0x3c070001, 0x24e77dd0, 0xc002d3b, 0x3405dead, +0x8f82011c, 0x34420002, 0xaf82011c, 0x8f820220, +0x34420004, 0xaf820220, 0x8f820140, 0x3c030001, +0x431025, 0xaf820140, 0x2005821, 0x22b102a, +0x54400001, 0x2205821, 0x8f4a006c, 0x8f49006c, +0x8f440198, 0x8f45019c, 0x8f46006c, 0xb3940, +0x24084000, 0xafa80010, 0x94940, 0x1201821, +0x1021, 0x14b5021, 0x315003ff, 0xafb00014, +0x8f480014, 0xa32821, 0xa3482b, 0x822021, +0x892021, 0x63140, 0xafa80018, 0x8f420108, +0x24c66cc0, 0x40f809, 0x2e63021, 0x54400001, +0xaf50006c, 0x8f43006c, 0x8f420068, 0x14620019, +0x0, 0x8f420000, 0x10400007, 0x0, +0xaf80004c, 0x8f82004c, 0x1040fffd, 0x0, +0x10000005, 0x0, 0xaf800048, 0x8f820048, +0x1040fffd, 0x0, 0x8f820060, 0x2403f7ff, +0x431024, 0xaf820060, 0x8f420000, 0x10400004, +0x0, 0xaf80004c, 0x10000002, 0x0, +0xaf800048, 0x8fbf0028, 0x8fb10024, 0x8fb00020, +0x3e00008, 0x27bd0030, 0x3e00008, 0x0, +0x27bdffe0, 0xafbf001c, 0xafb00018, 0x8f4200fc, +0x8f4400f8, 0x8f4300f4, 0x24420001, 0xaf4200fc, +0x8f900128, 0x14830016, 0x3c020001, 0x3c040001, +0x24847d84, 0x240209cc, 0xafa20010, 0xafa00014, +0x8f860144, 0x3c070001, 0x24e77dd0, 0xc002d3b, +0x3405dead, 0x8f82011c, 0x34420002, 0xaf82011c, +0x8f820220, 0x34420004, 0xaf820220, 0x8f820140, +0x3c030001, 0x431025, 0xaf820140, 0x3c020001, +0x8f4300f8, 0x344230c8, 0x2e21021, 0x54620004, +0x24620008, 0x3c020001, 0x34422ec8, 0x2e21021, +0x401821, 0xaf4300f8, 0xac600000, 0x8f4200f4, +0x14620005, 0x3c020001, 0x26020020, 0xaf820128, +0x1000000f, 0x0, 0x8f4300f8, 0x344230c8, +0x2e21021, 0x54620004, 0x24620008, 0x3c020001, +0x34422ec8, 0x2e21021, 0x401821, 0x8c620004, +0x21140, 0x2021021, 0xaf820128, 0xac600000, +0x8e030018, 0x30620070, 0x10400030, 0x30620020, +0x10400004, 0x3c020010, 0x2c21024, 0x1040000d, +0x0, 0x30620040, 0x10400004, 0x3c020020, +0x2c21024, 0x10400007, 0x0, 0x30620010, +0x10400038, 0x3c020040, 0x2c21024, 0x14400035, +0x0, 0x8f820040, 0x30420001, 0x14400008, +0x2021, 0x8c030104, 0x24020001, 0x50620005, +0x24040001, 0x8c020264, 0x10400003, 0x801021, +0x24040001, 0x801021, 0x10400007, 0x0, +0x8f42030c, 0x24420001, 0xaf42030c, 0x8f42030c, +0x10000020, 0x0, 0x8f820044, 0x34420004, +0xaf820044, 0x8f420308, 0x24420001, 0xaf420308, +0x8f420308, 0x10000017, 0x0, 0x3062b08f, +0x14400014, 0x240209fd, 0x3c040001, 0x24847d84, +0xafa20010, 0xafa00014, 0x8f860144, 0x3c070001, +0x24e77dd0, 0xc002d3b, 0x3405dead, 0x8f82011c, +0x34420002, 0xaf82011c, 0x8f820220, 0x34420004, +0xaf820220, 0x8f820140, 0x3c030001, 0x431025, +0xaf820140, 0x8fbf001c, 0x8fb00018, 0x3e00008, +0x27bd0020, 0x3e00008, 0x0, 0x27bdff98, +0xafbf0060, 0xafbe005c, 0xafb50058, 0xafb30054, +0xafb20050, 0xafb1004c, 0xafb00048, 0x8f4200fc, +0x24420001, 0xaf4200fc, 0x8f880128, 0x25020020, +0xaf820128, 0x8d030018, 0x30620070, 0x10400030, 0x30620020, 0x10400004, 0x3c020010, 0x2c21024, 0x1040000d, 0x0, 0x30620040, 0x10400004, 0x3c020020, 0x2c21024, 0x10400007, 0x0, -0x30620010, 0x1040001f, 0x3c020040, 0x2c21024, -0x1440001c, 0x0, 0x8f820040, 0x30420001, +0x30620010, 0x104001c0, 0x3c020040, 0x2c21024, +0x144001bd, 0x0, 0x8f820040, 0x30420001, 0x14400008, 0x2021, 0x8c030104, 0x24020001, 0x50620005, 0x24040001, 0x8c020264, 0x10400003, -0x801021, 0x24040001, 0x801021, 0x10400006, +0x801021, 0x24040001, 0x801021, 0x10400007, 0x0, 0x8f42030c, 0x24420001, 0xaf42030c, -0x10000008, 0x8f42030c, 0x8f820044, 0x34420004, -0xaf820044, 0x8f420308, 0x24420001, 0xaf420308, -0x8f420308, 0x3e00008, 0x0, 0x3e00008, -0x0, 0x27bdff98, 0xafbf0060, 0xafbe005c, -0xafb50058, 0xafb30054, 0xafb20050, 0xafb1004c, -0xafb00048, 0x8f4200fc, 0x24420001, 0xaf4200fc, -0x8f880128, 0x25020020, 0xaf820128, 0x8d030018, -0x30620070, 0x1040002e, 0x30620020, 0x10400004, -0x3c020010, 0x2c21024, 0x1040000d, 0x0, -0x30620040, 0x10400004, 0x3c020020, 0x2c21024, -0x10400007, 0x0, 0x30620010, 0x104001a9, -0x3c020040, 0x2c21024, 0x144001a6, 0x0, -0x8f820040, 0x30420001, 0x14400008, 0x2021, -0x8c030104, 0x24020001, 0x50620005, 0x24040001, -0x8c020264, 0x10400003, 0x801021, 0x24040001, -0x801021, 0x10400006, 0x0, 0x8f42030c, -0x24420001, 0xaf42030c, 0x10000192, 0x8f42030c, -0x8f820044, 0x34420004, 0xaf820044, 0x8f420308, -0x24420001, 0xaf420308, 0x1000018a, 0x8f420308, -0x30620002, 0x1040014b, 0x3c020800, 0x8d1e001c, +0x8f42030c, 0x100001a8, 0x0, 0x8f820044, +0x34420004, 0xaf820044, 0x8f420308, 0x24420001, +0xaf420308, 0x8f420308, 0x1000019f, 0x0, +0x30620002, 0x10400160, 0x3c020800, 0x8d1e001c, 0x1e5702, 0xafaa0034, 0x950a0016, 0x3c22024, 0xafaa0024, 0x8faa0034, 0x24020001, 0x15420006, 0x33deffff, 0x1e1140, 0x3403ecc0, 0x431021, @@ -2815,7 +3149,7 @@ 0x94820000, 0x2028021, 0x3c020100, 0x2c21024, 0x1040000e, 0x0, 0x8faa002c, 0x31420004, 0x1040000a, 0x0, 0x9504000e, 0x2642021, -0xc003ee8, 0x2484fffc, 0x3042ffff, 0x2228821, +0xc00447d, 0x2484fffc, 0x3042ffff, 0x2228821, 0x111c02, 0x3222ffff, 0x628821, 0x8faa0024, 0x1518823, 0x111402, 0x2228821, 0x2308821, 0x111402, 0x2228821, 0x3231ffff, 0x52200001, @@ -2826,134 +3160,152 @@ 0x8f490044, 0x84140, 0x1001821, 0xafa90014, 0x8f48000c, 0x2a03021, 0x24070020, 0xafa80018, 0x8f48010c, 0x1021, 0xa32821, 0xa3482b, -0x822021, 0x100f809, 0x892021, 0x1440000b, -0x0, 0x8f820128, 0x3c040001, 0x248469d4, +0x822021, 0x100f809, 0x892021, 0x1440001f, +0x0, 0x8f820128, 0x3c040001, 0x24847e1c, 0xafbe0014, 0xafa20010, 0x8f860124, 0x8f870120, -0x3c050007, 0xc002b37, 0x34a59920, 0x8f420368, +0x3c050007, 0xc002d3b, 0x34a59920, 0x3c040001, +0x24847d84, 0x24020c13, 0xafa20010, 0xafa00014, +0x8f860144, 0x3c070001, 0x24e77dd0, 0xc002d3b, +0x3405dead, 0x8f82011c, 0x34420002, 0xaf82011c, +0x8f820220, 0x34420004, 0xaf820220, 0x8f820140, +0x3c030001, 0x431025, 0xaf820140, 0x8f420368, 0x2442ffff, 0xaf420368, 0x8f420044, 0x8f430088, 0x24420001, 0x431024, 0xaf420044, 0x8faa0034, 0x8f440368, 0x24020001, 0x15420006, 0x24020002, -0x8f42035c, 0x2442ffff, 0xaf42035c, 0x10000049, +0x8f42035c, 0x2442ffff, 0xaf42035c, 0x1000004a, 0x8f42035c, 0x15420006, 0x0, 0x8f420364, -0x2442ffff, 0xaf420364, 0x10000042, 0x8f420364, -0x8f420360, 0x2442ffff, 0xaf420360, 0x1000003d, -0x8f420360, 0x30621000, 0x10400005, 0x30628000, -0x8f420078, 0x24420001, 0x10000036, 0xaf420078, -0x10400034, 0x0, 0x8f420078, 0x24420001, -0xaf420078, 0x8c030240, 0x43102b, 0x1440002d, -0x24070008, 0x8f440168, 0x8f45016c, 0x8f430044, -0x8f48000c, 0x8f860120, 0x24020040, 0xafa20010, -0xafa30014, 0xafa80018, 0x8f42010c, 0x40f809, -0x24c6001c, 0x14400011, 0x24020001, 0x3c010001, -0x370821, 0xa02240f2, 0x8f820124, 0xafa20010, -0x8f820128, 0x3c040001, 0x2484694c, 0xafa20014, -0x8f460044, 0x8f870120, 0x3c050009, 0xc002b37, -0x34a51300, 0x1000000b, 0x0, 0x8f420304, -0x24420001, 0xaf420304, 0x8f420304, 0x8f420044, -0xaf42007c, 0x3c010001, 0x370821, 0xa02040f2, -0xaf400078, 0x8f420318, 0x24420001, 0xaf420318, -0x8f420318, 0x8fbf0060, 0x8fbe005c, 0x8fb50058, -0x8fb30054, 0x8fb20050, 0x8fb1004c, 0x8fb00048, -0x3e00008, 0x27bd0068, 0x3e00008, 0x0, -0x0, 0x0, 0x0, 0x8f42013c, -0xaf8200c0, 0x8f42013c, 0xaf8200c4, 0x8f42013c, -0xaf8200c8, 0x8f420138, 0xaf8200d0, 0x8f420138, -0xaf8200d4, 0x8f420138, 0x3e00008, 0xaf8200d8, -0x27bdffe0, 0x27840208, 0x24050200, 0xafbf0018, -0xc002bbb, 0x24060008, 0x8c020204, 0xc00400e, -0xaf820210, 0x3c020001, 0x8c426e54, 0x30420002, -0x1040000e, 0x2021, 0x8c060248, 0x24020002, -0x3c010001, 0xac226e58, 0xc005134, 0x24050002, -0x2021, 0x8c060248, 0x24020001, 0x3c010001, -0xac226e58, 0x10000011, 0x24050001, 0x8c060248, -0x24020004, 0x3c010001, 0xac226e58, 0xc005134, -0x24050004, 0x3c020001, 0x8c426e54, 0x30420001, -0x10400008, 0x24020001, 0x3c010001, 0xac226e58, -0x2021, 0x24050001, 0x3c06601b, 0xc005134, -0x0, 0x3c040001, 0x24846a90, 0x8f420150, -0x8f430154, 0x3c050008, 0x8f460158, 0x21640, -0x31940, 0x34630403, 0x431025, 0x633c0, -0x461025, 0xaf82021c, 0xafa00010, 0xafa00014, -0x8f86021c, 0x34a50200, 0xc002b37, 0x3821, -0x3c010001, 0xac206e50, 0x3c010001, 0xac206e68, -0x8fbf0018, 0x3e00008, 0x27bd0020, 0x27bdffe0, -0x3c050008, 0x34a50300, 0xafbf0018, 0xafa00010, -0xafa00014, 0x8f860200, 0x3c040001, 0x24846a9c, -0xc002b37, 0x3821, 0x8f420410, 0x24420001, -0xaf420410, 0x8f420410, 0x8fbf0018, 0x3e00008, -0x27bd0020, 0x27bdffd8, 0xafbf0020, 0xafb1001c, -0xafb00018, 0x8f4203a4, 0x24420001, 0xaf4203a4, -0x8f4203a4, 0x8f900220, 0x8f8200e0, 0xafa20010, -0x8f8200e4, 0xafa20014, 0x8f8600c4, 0x8f8700c8, -0x3c040001, 0x24846aa8, 0xc002b37, 0x2002821, -0x3c044000, 0x2041024, 0x504000b4, 0x3c040100, -0x8f4203bc, 0x24420001, 0xaf4203bc, 0x8f4203bc, -0x8f8700c4, 0x8f8300c8, 0x8f420148, 0x671823, -0x43102b, 0x10400003, 0x0, 0x8f420148, -0x621821, 0x10600005, 0x0, 0x8f42014c, -0x43102b, 0x1040000b, 0x0, 0x8f8200e0, -0x8f430124, 0xaf42011c, 0xaf430114, 0x8f820220, -0x3c0308ff, 0x3463fffb, 0x431024, 0x100000ce, -0x441025, 0x8f820220, 0x3c0308ff, 0x3463ffff, -0x431024, 0x34420004, 0xaf820220, 0x8f8200e0, -0x8f430124, 0xaf42011c, 0xaf430114, 0x8f8600c8, -0x8f840120, 0x8f830124, 0x10000005, 0x2821, -0x14620002, 0x24620020, 0x27624800, 0x401821, -0x1064000c, 0x30a200ff, 0x8c620018, 0x30420003, -0x1040fff7, 0x27624fe0, 0x8f4203d0, 0x24050001, -0x24420001, 0xaf4203d0, 0x8f4203d0, 0x8c660008, -0x30a200ff, 0x14400058, 0x0, 0x934205c4, -0x14400055, 0x0, 0x8f8700c4, 0x8f8800e0, -0x8f8400e4, 0x2402fff8, 0x1024024, 0x1041023, -0x218c3, 0x4620001, 0x24630200, 0x10600005, -0x24020001, 0x10620009, 0x0, 0x1000001f, -0x0, 0x8f4203c0, 0xe03021, 0x24420001, -0xaf4203c0, 0x10000040, 0x8f4203c0, 0x8f4203c4, +0x2442ffff, 0xaf420364, 0x10000043, 0x8f420364, +0x8f420360, 0x2442ffff, 0xaf420360, 0x8f420360, +0x1000003d, 0x0, 0x30621000, 0x10400005, +0x30628000, 0x8f420078, 0x24420001, 0x10000036, +0xaf420078, 0x10400034, 0x0, 0x8f420078, +0x24420001, 0xaf420078, 0x8c030240, 0x43102b, +0x1440002d, 0x24070008, 0x8f440168, 0x8f45016c, +0x8f430044, 0x8f48000c, 0x8f860120, 0x24020040, +0xafa20010, 0xafa30014, 0xafa80018, 0x8f42010c, +0x40f809, 0x24c6001c, 0x14400011, 0x24020001, +0x3c010001, 0x370821, 0xa02240f2, 0x8f820124, +0xafa20010, 0x8f820128, 0x3c040001, 0x24847d7c, +0xafa20014, 0x8f460044, 0x8f870120, 0x3c050009, +0xc002d3b, 0x34a51300, 0x1000000b, 0x0, +0x8f420304, 0x24420001, 0xaf420304, 0x8f420304, +0x8f420044, 0xaf42007c, 0x3c010001, 0x370821, +0xa02040f2, 0xaf400078, 0x8f420318, 0x24420001, +0xaf420318, 0x8f420318, 0x8fbf0060, 0x8fbe005c, +0x8fb50058, 0x8fb30054, 0x8fb20050, 0x8fb1004c, +0x8fb00048, 0x3e00008, 0x27bd0068, 0x3e00008, +0x0, 0x8f42013c, 0xaf8200c0, 0x8f42013c, +0xaf8200c4, 0x8f42013c, 0xaf8200c8, 0x8f420138, +0xaf8200d0, 0x8f420138, 0xaf8200d4, 0x8f420138, +0x3e00008, 0xaf8200d8, 0x27bdffe0, 0x27840208, +0x24050200, 0xafbf0018, 0xc002dbf, 0x24060008, +0x8c020204, 0xaf820210, 0xc0045be, 0x0, +0x3c020002, 0x8c4284c8, 0x30420002, 0x1040000c, +0x2021, 0x8c060248, 0x2021, 0xc0056f1, +0x24050001, 0x2021, 0x8c060248, 0x24020002, +0x3c010002, 0xac2284cc, 0x10000011, 0x24050002, +0x8c060248, 0x24020004, 0x3c010002, 0xac2284cc, +0xc0056f1, 0x24050004, 0x3c020002, 0x8c4284c8, +0x30420001, 0x10400008, 0x24020001, 0x3c010002, +0xac2284cc, 0x2021, 0x24050001, 0x3c06601b, +0xc0056f1, 0x0, 0x3c040001, 0x24847ee8, +0x8f420150, 0x8f430154, 0x3c050008, 0x8f460158, +0x21640, 0x31940, 0x34630403, 0x431025, +0x633c0, 0x461025, 0xaf82021c, 0xafa00010, +0xafa00014, 0x8f86021c, 0x34a50200, 0xc002d3b, +0x3821, 0x3c010002, 0xac2084c4, 0x3c010002, +0xac2084dc, 0x8fbf0018, 0x3e00008, 0x27bd0020, +0x27bdffe0, 0x3c050008, 0x34a50300, 0xafbf0018, +0xafa00010, 0xafa00014, 0x8f860200, 0x3c040001, +0x24847ef4, 0xc002d3b, 0x3821, 0x8f420410, +0x24420001, 0xaf420410, 0x8f420410, 0x8fbf0018, +0x3e00008, 0x27bd0020, 0x27bdffd8, 0xafbf0020, +0xafb1001c, 0xafb00018, 0x8f4203a4, 0x24420001, +0xaf4203a4, 0x8f4203a4, 0x8f900220, 0x8f8200e0, +0xafa20010, 0x8f8200e4, 0xafa20014, 0x8f8600c4, +0x8f8700c8, 0x3c040001, 0x24847f00, 0xc002d3b, +0x2002821, 0x3c044000, 0x2041024, 0x504000bc, +0x3c040100, 0x8f4203bc, 0x24420001, 0xaf4203bc, +0x8f4203bc, 0x8f8700c4, 0x8f8300c8, 0x8f420148, +0x671823, 0x43102b, 0x10400003, 0x0, +0x8f420148, 0x621821, 0x10600005, 0x0, +0x8f42014c, 0x43102b, 0x1040000d, 0x0, +0x8f8200e0, 0x8f430124, 0xaf42011c, 0xaf430114, +0x8f820220, 0x3c0308ff, 0x3463fffb, 0x431024, +0x441025, 0xaf820220, 0x10000104, 0x0, +0x8f820220, 0x3c0308ff, 0x3463ffff, 0x431024, +0x34420004, 0xaf820220, 0x8f8200e0, 0x8f430124, +0xaf42011c, 0xaf430114, 0x8f8600c8, 0x8f840120, +0x8f830124, 0x10000005, 0x2821, 0x14620002, +0x24620020, 0x27624800, 0x401821, 0x1064000c, +0x30a200ff, 0x8c620018, 0x30420003, 0x1040fff7, +0x27624fe0, 0x8f4203d0, 0x24050001, 0x24420001, +0xaf4203d0, 0x8f4203d0, 0x8c660008, 0x30a200ff, +0x1440005b, 0x0, 0x934205c4, 0x14400058, +0x0, 0x8f8700c4, 0x8f8800e0, 0x8f8400e4, +0x2402fff8, 0x1024024, 0x1041023, 0x218c3, +0x4620001, 0x24630200, 0x10600005, 0x24020001, +0x1062000a, 0x0, 0x10000021, 0x0, +0x8f4203c0, 0xe03021, 0x24420001, 0xaf4203c0, +0x8f4203c0, 0x10000042, 0x0, 0x8f4203c4, 0x24420001, 0xaf4203c4, 0x8c860000, 0x8f420148, 0x8f4303c4, 0xe61823, 0x43102b, 0x10400004, 0x2c62233f, 0x8f420148, 0x621821, 0x2c62233f, -0x14400031, 0x0, 0x8f42020c, 0x24420001, +0x14400033, 0x0, 0x8f42020c, 0x24420001, 0xaf42020c, 0x8f42020c, 0xe03021, 0x24820008, -0xaf8200e4, 0x10000028, 0xaf8200e8, 0x8f4203c8, -0x24420001, 0xaf4203c8, 0x8f4203c8, 0x8c850000, -0x8f420148, 0xa71823, 0x43102b, 0x10400003, -0x0, 0x8f420148, 0x621821, 0x8f42014c, -0x43102b, 0x5440000a, 0xa03021, 0x8f42020c, -0x24420001, 0xaf42020c, 0x8f42020c, 0x24820008, -0xaf8200e4, 0x8f8400e4, 0x1488ffec, 0xaf8400e8, -0x1488000d, 0x27623000, 0x14820002, 0x2482fff8, -0x27623ff8, 0x94430006, 0x3c02001f, 0x3442ffff, -0xc33021, 0x46102b, 0x10400003, 0x0, -0x8f420148, 0xc23023, 0xaf8600c8, 0x8f8300c4, -0x8f420148, 0xc31823, 0x43102b, 0x10400003, -0x0, 0x8f420148, 0x621821, 0x10600005, -0x0, 0x8f42014c, 0x43102b, 0x50400008, -0x3c02fdff, 0x8f820220, 0x3c0308ff, 0x3463fffb, -0x431024, 0x3c034000, 0x1000003f, 0x431025, +0xaf8200e4, 0xaf8200e8, 0x10000029, 0x0, +0x8f4203c8, 0x24420001, 0xaf4203c8, 0x8f4203c8, +0x8c850000, 0x8f420148, 0xa71823, 0x43102b, +0x10400003, 0x0, 0x8f420148, 0x621821, +0x8f42014c, 0x43102b, 0x5440000b, 0xa03021, +0x8f42020c, 0x24420001, 0xaf42020c, 0x8f42020c, +0x24820008, 0xaf8200e4, 0x8f8400e4, 0xaf8400e8, +0x1488ffeb, 0x0, 0x1488000d, 0x27623000, +0x14820002, 0x2482fff8, 0x27623ff8, 0x94430006, +0x3c02001f, 0x3442ffff, 0xc33021, 0x46102b, +0x10400003, 0x0, 0x8f420148, 0xc23023, +0xaf8600c8, 0x8f8300c4, 0x8f420148, 0xc31823, +0x43102b, 0x10400003, 0x0, 0x8f420148, +0x621821, 0x10600005, 0x0, 0x8f42014c, +0x43102b, 0x1040000a, 0x3c02fdff, 0x8f820220, +0x3c0308ff, 0x3463fffb, 0x431024, 0x3c034000, +0x431025, 0xaf820220, 0x10000070, 0x0, 0x8f4303cc, 0x3442ffff, 0x282a024, 0x24630001, -0xaf4303cc, 0x10000039, 0x8f4203cc, 0x2041024, -0x1040000e, 0x3c110200, 0x8f4203a8, 0x24420001, -0xaf4203a8, 0x8f4203a8, 0x8f820220, 0x3c0308ff, -0x3463ffff, 0x431024, 0x441025, 0xc003dab, -0xaf820220, 0x10000029, 0x0, 0x2111024, -0x50400008, 0x3c110400, 0x8f4203ac, 0x24420001, -0xaf4203ac, 0xc003dab, 0x8f4203ac, 0x10000019, -0x0, 0x2111024, 0x1040001c, 0x0, -0x8f830224, 0x24021402, 0x14620009, 0x3c050008, -0x3c040001, 0x24846ab4, 0xafa00010, 0xafa00014, -0x8f860224, 0x34a50500, 0xc002b37, 0x3821, -0x8f4203b0, 0x24420001, 0xaf4203b0, 0x8f4203b0, -0x8f820220, 0x2002021, 0x34420002, 0xc004ecc, -0xaf820220, 0x8f820220, 0x3c0308ff, 0x3463ffff, -0x431024, 0x511025, 0xaf820220, 0x8fbf0020, +0xaf4303cc, 0x8f4203cc, 0x10000068, 0x0, +0x2041024, 0x1040000f, 0x3c110200, 0x8f4203a8, +0x24420001, 0xaf4203a8, 0x8f4203a8, 0x8f820220, +0x3c0308ff, 0x3463ffff, 0x431024, 0x441025, +0xaf820220, 0xc004343, 0x0, 0x10000057, +0x0, 0x2111024, 0x50400009, 0x3c110400, +0x8f4203ac, 0x24420001, 0xaf4203ac, 0x8f4203ac, +0xc004343, 0x0, 0x1000002e, 0x0, +0x2111024, 0x10400033, 0x3c02b800, 0x8f830224, +0x24021402, 0x1462001d, 0x3c050008, 0x3c040001, +0x24847f0c, 0xafa00010, 0xafa00014, 0x8f860224, +0x34a50500, 0xc002d3b, 0x3821, 0x3c040001, +0x24847ed8, 0x240203b6, 0xafa20010, 0xafa00014, +0x8f860144, 0x3c070001, 0x24e77f18, 0xc002d3b, +0x3405dead, 0x8f82011c, 0x34420002, 0xaf82011c, +0x8f820220, 0x34420004, 0xaf820220, 0x8f820140, +0x3c030001, 0x431025, 0xaf820140, 0x8f4203b0, +0x24420001, 0xaf4203b0, 0x8f4203b0, 0x8f820220, +0x2002021, 0x34420002, 0xaf820220, 0xc005477, +0x0, 0x8f820220, 0x3c0308ff, 0x3463ffff, +0x431024, 0x511025, 0xaf820220, 0x10000017, +0x0, 0x2021024, 0x10400014, 0x240203ca, +0x3c040001, 0x24847ed8, 0xafa20010, 0xafa00014, +0x8f860144, 0x3c070001, 0x24e77f18, 0xc002d3b, +0x3405dead, 0x8f82011c, 0x34420002, 0xaf82011c, +0x8f820220, 0x34420004, 0xaf820220, 0x8f820140, +0x3c030001, 0x431025, 0xaf820140, 0x8fbf0020, 0x8fb1001c, 0x8fb00018, 0x3e00008, 0x27bd0028, -0x3e00008, 0x0, 0x3c020001, 0x8c426e68, +0x3e00008, 0x0, 0x3c020002, 0x8c4284dc, 0x27bdffb0, 0xafbf0048, 0xafbe0044, 0xafb50040, 0xafb3003c, 0xafb20038, 0xafb10034, 0x1040000f, -0xafb00030, 0x3c040001, 0x24846ac0, 0x3c050008, +0xafb00030, 0x3c040001, 0x24847f20, 0x3c050008, 0xafa00010, 0xafa00014, 0x8f860220, 0x34a50600, -0x24020001, 0x3c010001, 0xac206e68, 0x3c010001, -0xac226e5c, 0xc002b37, 0x3821, 0x3c037fff, +0x24020001, 0x3c010002, 0xac2084dc, 0x3c010002, +0xac2284d0, 0xc002d3b, 0x3821, 0x3c037fff, 0x8c020268, 0x3463ffff, 0x3c04fdff, 0x431024, 0xac020268, 0x8f420004, 0x3484ffff, 0x30420002, 0x10400092, 0x284a024, 0x3c040600, 0x34842000, @@ -2962,7 +3314,7 @@ 0x240200ff, 0x13c20002, 0xafaa002c, 0x27c50001, 0x8c020228, 0xa09021, 0x1642000e, 0x1e38c0, 0x8f42033c, 0x24420001, 0xaf42033c, 0x8f42033c, -0x8c020228, 0x3c040001, 0x24846a58, 0x3c050009, +0x8c020228, 0x3c040001, 0x24847ea0, 0x3c050009, 0xafa00014, 0xafa20010, 0x8fa60020, 0x1000006d, 0x34a50500, 0xf71021, 0x8fa30020, 0x8fa40024, 0xac4304c0, 0xac4404c4, 0x8f830054, 0x8f820054, @@ -2976,7 +3328,7 @@ 0x2c4203e9, 0x1440ffe9, 0x0, 0x326200ff, 0x54400017, 0xaf520018, 0x8f420378, 0x24420001, 0xaf420378, 0x8f420378, 0x8f820120, 0x8faa002c, -0xafa20010, 0x8f820124, 0x3c040001, 0x24846a64, +0xafa20010, 0x8f820124, 0x3c040001, 0x24847eac, 0x3c050009, 0xafa20014, 0x8d460000, 0x10000035, 0x34a50600, 0x8f420308, 0x24130001, 0x24420001, 0xaf420308, 0x8f420308, 0x1000001e, 0x326200ff, @@ -2990,21 +3342,21 @@ 0x326200ff, 0x14400011, 0x0, 0x8f420378, 0x24420001, 0xaf420378, 0x8f420378, 0x8f820120, 0x8faa002c, 0xafa20010, 0x8f820124, 0x3c040001, -0x24846a6c, 0x3c050009, 0xafa20014, 0x8d460000, -0x34a50700, 0xc002b37, 0x3c03821, 0x8f4202ec, +0x24847eb4, 0x3c050009, 0xafa20014, 0x8d460000, +0x34a50700, 0xc002d3b, 0x3c03821, 0x8f4202ec, 0x24420001, 0xaf4202ec, 0x8f4202ec, 0x8fbf0048, 0x8fbe0044, 0x8fb50040, 0x8fb3003c, 0x8fb20038, 0x8fb10034, 0x8fb00030, 0x3e00008, 0x27bd0050, -0x3c020001, 0x8c426e68, 0x27bdffe0, 0x1440000d, -0xafbf0018, 0x3c040001, 0x24846acc, 0x3c050008, +0x3c020002, 0x8c4284dc, 0x27bdffe0, 0x1440000d, +0xafbf0018, 0x3c040001, 0x24847f2c, 0x3c050008, 0xafa00010, 0xafa00014, 0x8f860220, 0x34a50700, -0x24020001, 0x3c010001, 0xac226e68, 0xc002b37, +0x24020001, 0x3c010002, 0xac2284dc, 0xc002d3b, 0x3821, 0x3c020004, 0x2c21024, 0x10400007, 0x0, 0x8f820220, 0x3c0308ff, 0x3463ffff, -0x431024, 0x34420008, 0xaf820220, 0x3c050001, -0x8ca56e58, 0x24020001, 0x14a20007, 0x2021, -0xc0052cb, 0x24050001, 0xac02026c, 0x8c03026c, -0x10000006, 0x3c020007, 0xc0052cb, 0x2021, +0x431024, 0x34420008, 0xaf820220, 0x3c050002, +0x8ca584cc, 0x24020001, 0x14a20007, 0x2021, +0xc005897, 0x24050001, 0xac02026c, 0x8c03026c, +0x10000006, 0x3c020007, 0xc005897, 0x2021, 0xac020268, 0x8c030268, 0x3c020007, 0x621824, 0x3c020002, 0x5062000d, 0x3c0205f5, 0x43102b, 0x14400006, 0x3c020004, 0x3c020001, 0x10620009, @@ -3012,47 +3364,46 @@ 0x3c023b9a, 0x10000004, 0x3442ca00, 0x10000002, 0x3442e100, 0x34429680, 0xaf4201fc, 0x8f4201fc, 0xaee20064, 0x8fbf0018, 0x3e00008, 0x27bd0020, -0x0, 0x0, 0x0, 0x86102b, -0x50400001, 0x872023, 0xc41023, 0x24843, -0x125102b, 0x1040001b, 0x91040, 0x824021, -0x88102b, 0x10400007, 0x1821, 0x94820000, -0x24840002, 0x621821, 0x88102b, 0x1440fffb, -0x0, 0x602021, 0xc73023, 0xa91023, -0x21040, 0xc22821, 0xc5102b, 0x10400007, -0x1821, 0x94c20000, 0x24c60002, 0x621821, -0xc5102b, 0x1440fffb, 0x0, 0x1000000d, -0x832021, 0x51040, 0x822821, 0x85102b, -0x10400007, 0x1821, 0x94820000, 0x24840002, -0x621821, 0x85102b, 0x1440fffb, 0x0, -0x602021, 0x41c02, 0x3082ffff, 0x622021, -0x41c02, 0x3082ffff, 0x622021, 0x3e00008, -0x3082ffff, 0x3e00008, 0x0, 0x802821, -0x30a20001, 0x1040002b, 0x3c03001f, 0x3463ffff, -0x24a20004, 0x62102b, 0x54400007, 0x65102b, -0x90a20001, 0x90a40003, 0x90a30000, 0x90a50002, -0x1000002a, 0x441021, 0x10400003, 0x0, -0x8f420148, 0xa22823, 0x90a40000, 0x24a50001, -0x65102b, 0x10400003, 0x0, 0x8f420148, -0xa22823, 0x90a20000, 0x24a50001, 0x21200, -0x822021, 0x65102b, 0x10400003, 0x0, +0x86102b, 0x50400001, 0x872023, 0xc41023, +0x24843, 0x125102b, 0x1040001b, 0x91040, +0x824021, 0x88102b, 0x10400007, 0x1821, +0x94820000, 0x24840002, 0x621821, 0x88102b, +0x1440fffb, 0x0, 0x602021, 0xc73023, +0xa91023, 0x21040, 0xc22821, 0xc5102b, +0x10400007, 0x1821, 0x94c20000, 0x24c60002, +0x621821, 0xc5102b, 0x1440fffb, 0x0, +0x1000000d, 0x832021, 0x51040, 0x822821, +0x85102b, 0x10400007, 0x1821, 0x94820000, +0x24840002, 0x621821, 0x85102b, 0x1440fffb, +0x0, 0x602021, 0x41c02, 0x3082ffff, +0x622021, 0x41c02, 0x3082ffff, 0x622021, +0x3e00008, 0x3082ffff, 0x3e00008, 0x0, +0x802821, 0x30a20001, 0x1040002b, 0x3c03001f, +0x3463ffff, 0x24a20004, 0x62102b, 0x54400007, +0x65102b, 0x90a20001, 0x90a40003, 0x90a30000, +0x90a50002, 0x1000002a, 0x441021, 0x10400003, +0x0, 0x8f420148, 0xa22823, 0x90a40000, +0x24a50001, 0x65102b, 0x10400003, 0x0, 0x8f420148, 0xa22823, 0x90a20000, 0x24a50001, -0x822021, 0x65102b, 0x10400003, 0x0, -0x8f420148, 0xa22823, 0x90a20000, 0x1000002d, -0x21200, 0x3463ffff, 0x24a20004, 0x62102b, -0x5440000a, 0x65102b, 0x90a20000, 0x90a40002, -0x90a30001, 0x90a50003, 0x441021, 0x21200, -0x651821, 0x10000020, 0x432021, 0x10400003, -0x0, 0x8f420148, 0xa22823, 0x90a20000, -0x24a50001, 0x22200, 0x65102b, 0x10400003, +0x21200, 0x822021, 0x65102b, 0x10400003, 0x0, 0x8f420148, 0xa22823, 0x90a20000, 0x24a50001, 0x822021, 0x65102b, 0x10400003, 0x0, 0x8f420148, 0xa22823, 0x90a20000, -0x24a50001, 0x21200, 0x822021, 0x65102b, +0x1000002d, 0x21200, 0x3463ffff, 0x24a20004, +0x62102b, 0x5440000a, 0x65102b, 0x90a20000, +0x90a40002, 0x90a30001, 0x90a50003, 0x441021, +0x21200, 0x651821, 0x10000020, 0x432021, 0x10400003, 0x0, 0x8f420148, 0xa22823, -0x90a20000, 0x822021, 0x41c02, 0x3082ffff, -0x622021, 0x41c02, 0x3082ffff, 0x622021, -0x3e00008, 0x3082ffff, 0x0, 0x8f820220, -0x34420002, 0xaf820220, 0x3c020002, 0x8c4290b8, +0x90a20000, 0x24a50001, 0x22200, 0x65102b, +0x10400003, 0x0, 0x8f420148, 0xa22823, +0x90a20000, 0x24a50001, 0x822021, 0x65102b, +0x10400003, 0x0, 0x8f420148, 0xa22823, +0x90a20000, 0x24a50001, 0x21200, 0x822021, +0x65102b, 0x10400003, 0x0, 0x8f420148, +0xa22823, 0x90a20000, 0x822021, 0x41c02, +0x3082ffff, 0x622021, 0x41c02, 0x3082ffff, +0x622021, 0x3e00008, 0x3082ffff, 0x8f820220, +0x34420002, 0xaf820220, 0x3c020002, 0x8c42a718, 0x30424000, 0x10400054, 0x24040001, 0x8f820200, 0x24067fff, 0x8f830200, 0x30450002, 0x2402fffd, 0x621824, 0xaf830200, 0xaf840204, 0x8f830054, @@ -3080,864 +3431,889 @@ 0x431024, 0x14400003, 0x0, 0x10000008, 0x1021, 0x8f820220, 0x34420002, 0xaf820220, 0x8f830220, 0x24020001, 0x641825, 0xaf830220, -0x3e00008, 0x0, 0x2021, 0x3c050100, -0x24020001, 0xaf80021c, 0xaf820200, 0xaf820220, -0x27625000, 0xaf8200c0, 0x27625000, 0xaf8200c4, -0x27625000, 0xaf8200c8, 0x27625000, 0xaf8200d0, -0x27625000, 0xaf8200d4, 0x27625000, 0xaf8200d8, -0x27623000, 0xaf8200e0, 0x27623000, 0xaf8200e4, -0x27623000, 0xaf8200e8, 0x27622800, 0xaf8200f0, -0x27622800, 0xaf8200f4, 0x27622800, 0xaf8200f8, -0x418c0, 0x24840001, 0x3631021, 0xac453004, -0x3631021, 0xac403000, 0x28820200, 0x1440fff9, -0x418c0, 0x2021, 0x418c0, 0x24840001, -0x3631021, 0xac402804, 0x3631021, 0xac402800, -0x28820100, 0x1440fff9, 0x418c0, 0xaf80023c, -0x24030080, 0x24040100, 0xac600000, 0x24630004, -0x64102b, 0x5440fffd, 0xac600000, 0x8f830040, -0x3c02f000, 0x621824, 0x3c025000, 0x1062000c, -0x43102b, 0x14400006, 0x3c026000, 0x3c024000, -0x10620008, 0x24020800, 0x10000008, 0x0, -0x10620004, 0x24020800, 0x10000004, 0x0, -0x24020700, 0x3c010001, 0xac226e6c, 0x3e00008, -0x0, 0x3c020001, 0x8c426e7c, 0x27bdffd0, +0x3e00008, 0x0, 0x27bdffe0, 0x2021, +0x3c050100, 0x24020001, 0xafbf0018, 0xaf80021c, +0xaf820200, 0xaf820220, 0x27625000, 0xaf8200c0, +0x27625008, 0xaf8200c4, 0x27625008, 0xaf8200c8, +0x27625000, 0xaf8200d0, 0x27625000, 0xaf8200d4, +0x27625000, 0xaf8200d8, 0x27623000, 0xaf8200e0, +0x27623000, 0xaf8200e4, 0x27623000, 0xaf8200e8, +0x27622800, 0xaf8200f0, 0x27622800, 0xaf8200f4, +0x27622800, 0xaf8200f8, 0x418c0, 0x24840001, +0x3631021, 0xac453004, 0x3631021, 0xac403000, +0x28820200, 0x1440fff9, 0x418c0, 0x2021, +0x418c0, 0x24840001, 0x3631021, 0xac402804, +0x3631021, 0xac402800, 0x28820100, 0x1440fff9, +0x418c0, 0xaf80023c, 0x24030080, 0x24040100, +0xac600000, 0x24630004, 0x64102b, 0x5440fffd, +0xac600000, 0x8f830040, 0x3c02f000, 0x621824, +0x3c025000, 0x1062000c, 0x43102b, 0x14400006, +0x3c026000, 0x3c024000, 0x1062000c, 0x24020800, +0x1000000e, 0x240202b4, 0x10620008, 0x24020800, +0x1000000a, 0x240202b4, 0x24020700, 0x3c010002, +0xac2284e0, 0x10000018, 0x0, 0x3c010002, +0xac2284e0, 0x10000014, 0x0, 0x3c040001, +0x24847ff8, 0xafa20010, 0xafa00014, 0x8f860144, +0x3c070002, 0x24e78010, 0xc002d3b, 0x3405dead, +0x8f82011c, 0x34420002, 0xaf82011c, 0x8f820220, +0x34420004, 0xaf820220, 0x8f820140, 0x3c030001, +0x431025, 0xaf820140, 0x8fbf0018, 0x3e00008, +0x27bd0020, 0x3c020002, 0x8c4284f0, 0x27bdffd0, 0xafbf002c, 0xafb20028, 0xafb10024, 0xafb00020, -0x3c010001, 0x10400005, 0xac206e54, 0xc004dce, -0x0, 0x3c010001, 0xac206e7c, 0x8f830054, -0x8f820054, 0x10000002, 0x24630064, 0x8f820054, -0x621023, 0x2c420065, 0x1440fffc, 0x0, -0xc004de9, 0x0, 0x24040001, 0x2821, -0x27a60018, 0x34028000, 0xc0045ee, 0xa7a20018, -0x8f830054, 0x8f820054, 0x10000002, 0x24630064, -0x8f820054, 0x621023, 0x2c420065, 0x1440fffc, -0x24040001, 0x24050001, 0xc0045ac, 0x27a60018, +0x3c010002, 0xac2084c8, 0x10400005, 0x0, +0xc0053a2, 0x0, 0x3c010002, 0xac2084f0, 0x8f830054, 0x8f820054, 0x10000002, 0x24630064, 0x8f820054, 0x621023, 0x2c420065, 0x1440fffc, -0x24040001, 0x24050001, 0xc0045ac, 0x27a60018, -0x8f830054, 0x8f820054, 0x10000002, 0x24630064, -0x8f820054, 0x621023, 0x2c420065, 0x1440fffc, -0x24040001, 0x3c060001, 0x24c66fe4, 0xc0045ac, -0x24050002, 0x8f830054, 0x8f820054, 0x10000002, +0x0, 0xc0053aa, 0x0, 0x24040001, +0x2821, 0x27a60018, 0x34028000, 0xc004c3a, +0xa7a20018, 0x8f830054, 0x8f820054, 0x10000002, +0x24630064, 0x8f820054, 0x621023, 0x2c420065, +0x1440fffc, 0x24040001, 0x24050001, 0xc004bf8, +0x27a60018, 0x8f830054, 0x8f820054, 0x10000002, +0x24630064, 0x8f820054, 0x621023, 0x2c420065, +0x1440fffc, 0x24040001, 0x24050001, 0xc004bf8, +0x27a60018, 0x8f830054, 0x8f820054, 0x10000002, 0x24630064, 0x8f820054, 0x621023, 0x2c420065, -0x1440fffc, 0x24040001, 0x24050003, 0x3c100001, -0x26106fe6, 0xc0045ac, 0x2003021, 0x97a60018, -0x3c070001, 0x94e76fe4, 0x3c040001, 0x24846ba0, -0xafa00014, 0x96020000, 0x3c05000d, 0x34a50100, -0xc002b37, 0xafa20010, 0x97a20018, 0x1040004d, -0x24036040, 0x96020000, 0x3042fff0, 0x1443000c, -0x24020020, 0x3c030001, 0x94636fe4, 0x1462000b, -0x24027830, 0x24020003, 0x3c010001, 0xac226e54, -0x24020005, 0x3c010001, 0x1000003f, 0xac226ff4, -0x3c030001, 0x94636fe4, 0x24027830, 0x1462000c, -0x24030010, 0x3c020001, 0x94426fe6, 0x3042fff0, -0x14430007, 0x24020003, 0x3c010001, 0xac226e54, -0x24020006, 0x3c010001, 0x1000002f, 0xac226ff4, -0x3c020001, 0x8c426e54, 0x3c030001, 0x94636fe4, -0x34420001, 0x3c010001, 0xac226e54, 0x24020015, -0x1462000b, 0x0, 0x3c020001, 0x94426fe6, -0x3042fff0, 0x3843f420, 0x2c630001, 0x3842f430, -0x2c420001, 0x621825, 0x1460001b, 0x24020003, -0x3c030001, 0x94636fe4, 0x24027810, 0x14620016, -0x24020002, 0x3c020001, 0x94426fe6, 0x3042fff0, -0x14400011, 0x24020002, 0x1000000f, 0x24020004, -0x3c020001, 0x8c426e54, 0x34420008, 0x3c010001, -0xac226e54, 0x1000005e, 0x24020004, 0x3c020001, -0x8c426e54, 0x34420004, 0x3c010001, 0x100000af, -0xac226e54, 0x24020001, 0x3c010001, 0xac227000, -0x3c020001, 0x8c426e54, 0x30420002, 0x144000b2, -0x3c09fff0, 0x24020e00, 0xaf820238, 0x8f840054, -0x8f820054, 0x24030008, 0x3c010001, 0xac236e58, -0x10000002, 0x248401f4, 0x8f820054, 0x821023, -0x2c4201f5, 0x1440fffc, 0x3c0200c8, 0x344201fb, +0x1440fffc, 0x24040001, 0x3c060002, 0x24c68644, +0xc004bf8, 0x24050002, 0x8f830054, 0x8f820054, +0x10000002, 0x24630064, 0x8f820054, 0x621023, +0x2c420065, 0x1440fffc, 0x24040001, 0x24050003, +0x3c100002, 0x26108646, 0xc004bf8, 0x2003021, +0x97a60018, 0x3c070002, 0x94e78644, 0x3c040002, +0x24848028, 0xafa00014, 0x96020000, 0x3c05000d, +0x34a50100, 0xc002d3b, 0xafa20010, 0x97a20018, +0x10400055, 0x24036040, 0x96020000, 0x3042fff0, +0x14430012, 0x24020020, 0x3c030002, 0x94638644, +0x14620011, 0x24027830, 0x24020003, 0x3c010002, +0xac2284c8, 0x24020005, 0x3c010002, 0xac228654, +0x3c010002, 0xac228660, 0x24020002, 0x3c010002, +0xac2284cc, 0x10000043, 0x0, 0x3c030002, +0x94638644, 0x24027830, 0x1462000d, 0x24030010, +0x3c020002, 0x94428646, 0x3042fff0, 0x14430008, +0x24020003, 0x3c010002, 0xac2284c8, 0x24020006, +0x3c010002, 0xac228654, 0x10000030, 0x0, +0x3c020002, 0x8c4284c8, 0x3c030002, 0x94638644, +0x34420001, 0x3c010002, 0xac2284c8, 0x24020015, +0x1462000b, 0x0, 0x3c020002, 0x94428646, +0x3043fff0, 0x3402f420, 0x14620003, 0x3402f430, +0x1000001e, 0x24020003, 0x1062001c, 0x24020007, +0x3c030002, 0x94638644, 0x24027810, 0x14620017, +0x24020002, 0x3c020002, 0x94428646, 0x3042fff0, +0x14400012, 0x24020002, 0x10000010, 0x24020004, +0x3c020002, 0x8c4284c8, 0x34420008, 0x3c010002, +0xac2284c8, 0x1000005f, 0x24020004, 0x3c020002, +0x8c4284c8, 0x34420004, 0x3c010002, 0xac2284c8, +0x100000af, 0x0, 0x24020001, 0x3c010002, +0xac228660, 0x3c020002, 0x8c4284c8, 0x30420002, +0x144000b4, 0x3c09fff0, 0x24020e00, 0xaf820238, +0x8f840054, 0x8f820054, 0x24030008, 0x3c010002, +0xac2384cc, 0x10000002, 0x248401f4, 0x8f820054, +0x821023, 0x2c4201f5, 0x1440fffc, 0x3c0200c8, +0x344201fb, 0xaf820238, 0x8f830054, 0x8f820054, +0x10000002, 0x246301f4, 0x8f820054, 0x621023, +0x2c4201f5, 0x1440fffc, 0x8021, 0x24120001, +0x24110009, 0xc004ab2, 0x0, 0x3c010002, +0xac3284e8, 0xc004b7b, 0x0, 0x3c020002, +0x8c4284e8, 0x1451fffb, 0x3c0200c8, 0x344201f6, 0xaf820238, 0x8f830054, 0x8f820054, 0x10000002, -0x246301f4, 0x8f820054, 0x621023, 0x2c4201f5, -0x1440fffc, 0x8021, 0x24120001, 0x24110009, -0xc0044b5, 0x0, 0x3c010001, 0xac326e74, -0xc00457a, 0x0, 0x3c020001, 0x8c426e74, -0x1451fffb, 0x3c0200c8, 0x344201f6, 0xaf820238, -0x8f830054, 0x8f820054, 0x10000002, 0x2463000a, -0x8f820054, 0x621023, 0x2c42000b, 0x1440fffc, -0x0, 0x8f820220, 0x24040001, 0x34420002, -0xaf820220, 0x8f830200, 0x24057fff, 0x2402fffd, -0x621824, 0xaf830200, 0xaf840204, 0x8f830054, +0x2463000a, 0x8f820054, 0x621023, 0x2c42000b, +0x1440fffc, 0x0, 0x8f820220, 0x24040001, +0x34420002, 0xaf820220, 0x8f830200, 0x24057fff, +0x2402fffd, 0x621824, 0xaf830200, 0xaf840204, +0x8f830054, 0x8f820054, 0x10000002, 0x24630001, +0x8f820054, 0x621023, 0x2c420002, 0x1440fffc, +0x0, 0x8f820224, 0x14440005, 0x34028000, +0x42040, 0xa4102b, 0x1040fff0, 0x34028000, +0x1082ff9f, 0x26100001, 0x2e020014, 0x1440ffcd, +0x24020004, 0x3c010002, 0xac2284cc, 0x8021, +0x24120009, 0x3c11ffff, 0x36313f7f, 0xc004ab2, +0x0, 0x24020001, 0x3c010002, 0xac2284e8, +0xc004b7b, 0x0, 0x3c020002, 0x8c4284e8, +0x1452fffb, 0x0, 0x8f820200, 0x2403fffd, +0x431024, 0xaf820200, 0x8f820044, 0x511024, +0x34427080, 0xaf820044, 0x8f830054, 0x8f820054, +0x10000002, 0x2463000a, 0x8f820054, 0x621023, +0x2c42000b, 0x1440fffc, 0x0, 0x8f820044, +0x511024, 0x3442f080, 0xaf820044, 0x8f830054, +0x8f820054, 0x10000002, 0x2463000a, 0x8f820054, +0x621023, 0x2c42000b, 0x1440fffc, 0x0, +0x8f820220, 0x3c03f700, 0x431025, 0xaf820220, +0x8f830054, 0x8f820054, 0x10000002, 0x24630064, +0x8f820054, 0x621023, 0x2c420065, 0x1440fffc, +0x0, 0x8f820220, 0x24040001, 0x24057fff, +0x34420002, 0xaf820220, 0xaf840204, 0x8f830054, 0x8f820054, 0x10000002, 0x24630001, 0x8f820054, 0x621023, 0x2c420002, 0x1440fffc, 0x0, 0x8f820224, 0x14440005, 0x34028000, 0x42040, -0xa4102b, 0x1040fff0, 0x34028000, 0x1082ffa0, -0x26100001, 0x2e020014, 0x1440ffcd, 0x24020004, -0x3c010001, 0xac226e58, 0x8021, 0x24120009, -0x3c11ffff, 0x36313f7f, 0xc0044b5, 0x0, -0x24020001, 0x3c010001, 0xac226e74, 0xc00457a, -0x0, 0x3c020001, 0x8c426e74, 0x1452fffb, -0x0, 0x8f820044, 0x511024, 0x34425080, -0xaf820044, 0x8f830054, 0x8f820054, 0x10000002, -0x2463000a, 0x8f820054, 0x621023, 0x2c42000b, -0x1440fffc, 0x0, 0x8f820044, 0x511024, -0x3442f080, 0xaf820044, 0x8f830054, 0x8f820054, -0x10000002, 0x2463000a, 0x8f820054, 0x621023, -0x2c42000b, 0x1440fffc, 0x0, 0x8f820220, -0x3c03f700, 0x431025, 0xaf820220, 0x8f830054, -0x8f820054, 0x10000002, 0x24630064, 0x8f820054, -0x621023, 0x2c420065, 0x1440fffc, 0x0, -0x8f820220, 0x24040001, 0x34420002, 0xaf820220, -0x8f830200, 0x24057fff, 0x2402fffd, 0x621824, -0xaf830200, 0xaf840204, 0x8f830054, 0x8f820054, -0x10000002, 0x24630001, 0x8f820054, 0x621023, -0x2c420002, 0x1440fffc, 0x0, 0x8f820224, -0x14440005, 0x34028000, 0x42040, 0xa4102b, -0x1040fff0, 0x34028000, 0x1082ff50, 0x26100001, -0x2e020064, 0x1440ffb0, 0x0, 0x3c020001, -0x8c426e54, 0x30420004, 0x14400007, 0x3c09fff0, -0x8f820044, 0x3c03ffff, 0x34633f7f, 0x431024, -0xaf820044, 0x3c09fff0, 0x3529bdc0, 0x3c060001, -0x8cc66e54, 0x3c040001, 0x24846ba0, 0x24020001, -0x3c010001, 0xac226e5c, 0x8f820054, 0x3c070001, -0x8ce77000, 0x3c030001, 0x94636fe4, 0x3c080001, -0x95086fe6, 0x3c05000d, 0x34a50100, 0x3c010001, -0xac206e58, 0x491021, 0x3c010001, 0xac226ff0, -0xafa30010, 0xc002b37, 0xafa80014, 0x8fbf002c, -0x8fb20028, 0x8fb10024, 0x8fb00020, 0x3e00008, -0x27bd0030, 0x27bdffe8, 0x3c050001, 0x8ca56e58, -0x24060004, 0x24020001, 0x14a20014, 0xafbf0010, -0x3c020002, 0x8c4290bc, 0x30428000, 0x10400005, -0x3c04000f, 0x3c030001, 0x8c637000, 0x10000005, -0x34844240, 0x3c040004, 0x3c030001, 0x8c637000, -0x348493e0, 0x24020005, 0x14620016, 0x0, -0x3c04003d, 0x10000013, 0x34840900, 0x3c020002, -0x8c4290b8, 0x30428000, 0x10400005, 0x3c04001e, -0x3c030001, 0x8c637000, 0x10000005, 0x34848480, -0x3c04000f, 0x3c030001, 0x8c637000, 0x34844240, -0x24020005, 0x14620003, 0x0, 0x3c04007a, -0x34841200, 0x3c020001, 0x8c426ff0, 0x8f830054, -0x441021, 0x431023, 0x44102b, 0x1440004c, -0x0, 0x3c020001, 0x8c426e60, 0x14400048, -0x0, 0x3c010001, 0x10c00025, 0xac206e70, -0x3c090001, 0x8d296e54, 0x24070001, 0x3c044000, -0x3c080002, 0x250890bc, 0x250afffc, 0x52842, -0x14a00002, 0x24c6ffff, 0x24050008, 0xa91024, -0x10400010, 0x0, 0x14a70008, 0x0, -0x8d020000, 0x441024, 0x1040000a, 0x0, -0x3c010001, 0x10000007, 0xac256e70, 0x8d420000, -0x441024, 0x10400003, 0x0, 0x3c010001, -0xac276e70, 0x3c020001, 0x8c426e70, 0x6182b, -0x2c420001, 0x431024, 0x5440ffe5, 0x52842, -0x8f820054, 0x3c030001, 0x8c636e70, 0x3c010001, -0xac226ff0, 0x1060003b, 0x24020005, 0x3c030001, -0x8c637000, 0x3c010001, 0xac256e58, 0x14620012, -0x24020001, 0x3c020002, 0x8c4290b8, 0x3c032000, -0x34635000, 0x431024, 0x14400006, 0x24020001, -0x3c010001, 0xac206fdc, 0x3c010001, 0xac226e58, -0x24020001, 0x3c010001, 0xac226ee4, 0x3c010001, -0xac226e64, 0x24020001, 0x3c010001, 0xac226e5c, -0x3c020001, 0x8c426e70, 0x1040001e, 0x0, -0x3c020001, 0x8c426e5c, 0x10400008, 0x24020001, -0x3c010001, 0xac206e5c, 0xaee204b8, 0x3c010001, -0xac206edc, 0x3c010001, 0xac226e94, 0x8ee304b8, -0x24020008, 0x10620005, 0x24020001, 0xc004235, -0x0, 0x1000000b, 0x0, 0x3c030001, -0x8c636e58, 0x10620007, 0x2402000e, 0x3c030002, -0x8c639050, 0x10620003, 0x0, 0xc004ecc, -0x8f840220, 0x8fbf0010, 0x3e00008, 0x27bd0018, -0x27bdffd8, 0x3c03fdff, 0x3c040001, 0x8c846e58, -0x3c020001, 0x8c426e80, 0x3463ffff, 0x283a024, -0x14820006, 0xafbf0020, 0x8ee304b8, 0x3c020001, -0x8c426e84, 0x10620006, 0x0, 0x8ee204b8, -0x3c010001, 0xac246e80, 0x3c010001, 0xac226e84, -0x3c030001, 0x8c636e58, 0x24020002, 0x106201b0, -0x2c620003, 0x10400005, 0x24020001, 0x1062000a, -0x0, 0x1000025d, 0x0, 0x24020004, -0x106200d3, 0x24020008, 0x10620134, 0x24020001, -0x10000256, 0x0, 0x8ee204b8, 0x2443ffff, -0x2c620008, 0x10400253, 0x31080, 0x3c010001, -0x220821, 0x8c226bc0, 0x400008, 0x0, -0x3c030001, 0x8c637000, 0x24020005, 0x14620010, -0x0, 0x3c020001, 0x8c426e64, 0x10400008, -0x24020003, 0xc0044b5, 0x0, 0x24020002, -0xaee204b8, 0x3c010001, 0x10000002, 0xac206e64, -0xaee204b8, 0x3c010001, 0x1000023a, 0xac206df0, -0xc0044b5, 0x0, 0x3c020001, 0x8c426e64, -0x3c010001, 0xac206df0, 0x1440018e, 0x24020002, -0x100001d4, 0x24020007, 0x3c030001, 0x8c637000, -0x24020005, 0x14620003, 0x24020001, 0x3c010001, -0xac226e90, 0xc00462f, 0x0, 0x3c030001, -0x8c636e90, 0x10000188, 0x24020011, 0x3c050001, -0x8ca56e58, 0x3c060002, 0x8cc690bc, 0xc005134, -0x2021, 0x24020005, 0x3c010001, 0xac206e64, -0x10000218, 0xaee204b8, 0x3c040001, 0x24846bac, -0x3c05000f, 0x34a50100, 0x3021, 0x3821, -0xafa00010, 0xc002b37, 0xafa00014, 0x1000020d, -0x0, 0x24040001, 0x2405001a, 0x8f820220, -0x27a60018, 0x3c03f700, 0x431025, 0xc0045ac, -0xaf820220, 0x97a60018, 0x30c20200, 0x1040019a, -0x3c05000c, 0x3c040001, 0x24846bb8, 0x34a50111, -0x3c020001, 0x8c426e58, 0x3c030001, 0x8c636fdc, -0x3821, 0xafa20010, 0xc002b37, 0xafa30014, -0x2021, 0x2821, 0xc004e0b, 0x24064040, -0x10000187, 0x24020002, 0x8f820220, 0x3c030004, -0x431024, 0x1440018f, 0x24020007, 0x8f830054, -0x3c020001, 0x8c426fe8, 0x2463d8f0, 0x431023, -0x2c422710, 0x14400003, 0x24020001, 0x3c010001, -0xac226e5c, 0x3c020002, 0x8c4290bc, 0x30425000, -0x104001dc, 0x0, 0x8f820220, 0x30428000, -0x10400197, 0x0, 0x1000018f, 0x0, -0x3c050001, 0x8ca56e58, 0xc0052cb, 0x2021, -0xc00554b, 0x2021, 0x3c030002, 0x8c6390b4, -0x46101ca, 0x24020001, 0x3c020008, 0x621024, +0xa4102b, 0x1040fff0, 0x34028000, 0x1082ff4f, +0x26100001, 0x2e020064, 0x1440ffb0, 0x0, +0x3c020002, 0x8c4284c8, 0x30420004, 0x14400006, +0x0, 0x8f820044, 0x3c03ffff, 0x34633f7f, +0x431024, 0xaf820044, 0x3c010002, 0xac2084cc, +0x3c09fff0, 0x3529bdc0, 0x3c040002, 0x24848028, +0x3c060002, 0x8cc684c8, 0x3c05000d, 0x24020001, +0x3c010002, 0xac2284d0, 0x8f820054, 0x3c070002, +0x8ce78660, 0x3c030002, 0x94638644, 0x3c080002, +0x95088646, 0x34a50100, 0x491021, 0x3c010002, +0xac228650, 0xafa30010, 0xc002d3b, 0xafa80014, +0x8fbf002c, 0x8fb20028, 0x8fb10024, 0x8fb00020, +0x3e00008, 0x27bd0030, 0x27bdffe8, 0x3c040002, +0x8c8484cc, 0x24060004, 0x24020001, 0x14820014, +0xafbf0010, 0x3c020002, 0x8c42a71c, 0x30428000, +0x10400005, 0x3c05000f, 0x3c030002, 0x8c638660, +0x10000005, 0x34a54240, 0x3c050004, 0x3c030002, +0x8c638660, 0x34a593e0, 0x24020005, 0x14620016, +0x0, 0x3c05003d, 0x10000013, 0x34a50900, +0x3c020002, 0x8c42a718, 0x30428000, 0x10400005, +0x3c05001e, 0x3c030002, 0x8c638660, 0x10000005, +0x34a58480, 0x3c05000f, 0x3c030002, 0x8c638660, +0x34a54240, 0x24020005, 0x14620003, 0x0, +0x3c05007a, 0x34a51200, 0x3c030002, 0x8c638660, +0x24020005, 0x10620046, 0x0, 0x3c020002, +0x8c428650, 0x8f830054, 0x451021, 0x431023, +0xa2102b, 0x10400039, 0x0, 0x3c020002, +0x8c4284d4, 0x14400035, 0x0, 0x3c010002, +0xac2084e4, 0x10c00026, 0x0, 0x3c090002, +0x8d2984c8, 0x24070001, 0x3c054000, 0x3c080002, +0x2508a71c, 0x250afffc, 0x42042, 0x14800002, +0x24c6ffff, 0x24040008, 0x891024, 0x10400011, +0x0, 0x14870009, 0x0, 0x8d020000, +0x451024, 0x1040000b, 0x0, 0x3c010002, +0xac2484e4, 0x10000007, 0x0, 0x8d420000, +0x451024, 0x10400003, 0x0, 0x3c010002, +0xac2784e4, 0x3c020002, 0x8c4284e4, 0x6182b, +0x2c420001, 0x431024, 0x5440ffe4, 0x42042, +0x8f820054, 0x3c030002, 0x8c6384e4, 0x3c010002, +0xac228650, 0x1060004a, 0x24020001, 0x3c010002, +0xac2484cc, 0x3c010002, 0xac2284d0, 0x3c030002, +0x8c638660, 0x24020005, 0x14620024, 0x0, +0x3c030002, 0x8c63a718, 0x3c022000, 0x34425000, +0x621024, 0x14400007, 0x30625000, 0x24020001, +0x3c010002, 0xac20863c, 0x3c010002, 0xac2284cc, +0x30625000, 0x10400008, 0x3c020004, 0x621024, +0x14400005, 0x24020001, 0x3c010002, 0xac20863c, +0x3c010002, 0xac2284cc, 0x3c020002, 0x8c42a718, +0x3c032006, 0x34635000, 0x431024, 0x14400007, +0x24020001, 0x3c030002, 0x8c63854c, 0x10620003, +0x24020002, 0x3c010002, 0xac2284cc, 0x3c020002, +0x8c4284d0, 0x10400008, 0x24020001, 0x3c010002, +0xac2084d0, 0xaee204b8, 0x3c010002, 0xac208548, +0x3c010002, 0xac228500, 0x8ee304b8, 0x24020008, +0x10620005, 0x24020001, 0xc004804, 0x0, +0x1000000b, 0x0, 0x3c030002, 0x8c6384cc, +0x10620007, 0x2402000e, 0x3c030002, 0x8c63a6b0, +0x10620003, 0x0, 0xc005477, 0x8f840220, +0x8fbf0010, 0x3e00008, 0x27bd0018, 0x27bdffd8, +0x3c03fdff, 0x3c040002, 0x8c8484cc, 0x3c020002, +0x8c4284f4, 0x3463ffff, 0x283a024, 0x14820006, +0xafbf0020, 0x8ee304b8, 0x3c020002, 0x8c4284f8, +0x10620006, 0x0, 0x8ee204b8, 0x3c010002, +0xac2484f4, 0x3c010002, 0xac2284f8, 0x3c030002, +0x8c6384cc, 0x24020002, 0x106201da, 0x2c620003, +0x10400005, 0x24020001, 0x1062000a, 0x0, +0x1000028b, 0x0, 0x24020004, 0x106200f9, +0x24020008, 0x1062015c, 0x24020001, 0x10000284, +0x0, 0x8ee204b8, 0x2443ffff, 0x2c620008, +0x10400281, 0x31080, 0x3c010002, 0x220821, +0x8c228048, 0x400008, 0x0, 0x3c030002, +0x8c638660, 0x24020005, 0x1462000f, 0x0, +0x3c020002, 0x8c4284d8, 0x50400007, 0xaee304b8, +0xc004ab2, 0x0, 0x24020002, 0xaee204b8, +0x3c010002, 0xac2084d8, 0x3c010002, 0xac20846c, +0x10000269, 0x0, 0xc004ab2, 0x0, +0x3c020002, 0x8c4284d8, 0x3c010002, 0xac20846c, +0x144001b9, 0x24020002, 0x10000202, 0x24020007, +0x3c030002, 0x8c638660, 0x24020005, 0x14620003, +0x24020001, 0x3c010002, 0xac2284fc, 0xc004c7b, +0x0, 0x3c030002, 0x8c6384fc, 0x100001b4, +0x24020011, 0x3c050002, 0x8ca584cc, 0x3c060002, +0x8cc6a71c, 0xc0056f1, 0x2021, 0x24020005, +0x3c010002, 0xac2084d8, 0x10000247, 0xaee204b8, +0x3c040002, 0x24848034, 0x3c05000f, 0x34a50100, +0x3021, 0x3821, 0xafa00010, 0xc002d3b, +0xafa00014, 0x3c040001, 0x24847ff8, 0x240204da, +0xafa20010, 0xafa00014, 0x8f860144, 0x3c070002, +0x24e78010, 0xc002d3b, 0x3405dead, 0x8f82011c, +0x34420002, 0xaf82011c, 0x8f820220, 0x34420004, +0xaf820220, 0x8f820140, 0x3c030001, 0x431025, +0xaf820140, 0x10000228, 0x0, 0x24040001, +0x2405001a, 0x8f820220, 0x27a60018, 0x3c03f700, +0x431025, 0xaf820220, 0xc004bf8, 0x0, +0x97a60018, 0x30c20200, 0x104001b2, 0x3c05000c, +0x3c040002, 0x24848040, 0x34a50111, 0x3c020002, +0x8c4284cc, 0x3c030002, 0x8c63863c, 0x3821, +0xafa20010, 0xc002d3b, 0xafa30014, 0x2021, +0x2821, 0xc0053b9, 0x24064040, 0x1000019f, +0x24020002, 0x8f820220, 0x3c030004, 0x431024, +0x144001a8, 0x24020007, 0x8f830054, 0x3c020002, +0x8c428648, 0x2463d8f0, 0x431023, 0x2c422710, +0x14400003, 0x24020001, 0x3c010002, 0xac2284d0, +0x3c020002, 0x8c42a71c, 0x30425000, 0x104001f6, +0x0, 0x8f820220, 0x30428000, 0x104001b0, +0x0, 0x100001a8, 0x0, 0x3c030002, +0x8c638660, 0x24020005, 0x14620009, 0x0, +0x3c020002, 0x8c42a718, 0x30425000, 0x10400004, +0x2404001e, 0x24050001, 0xc0053b9, 0x24061000, +0x3c050002, 0x8ca584cc, 0xc005897, 0x2021, +0xc005ae7, 0x2021, 0x3c030002, 0x8c63a714, +0x46101d7, 0x24020001, 0x3c020008, 0x621024, 0x10400006, 0x0, 0x8f820214, 0x3c03ffff, 0x431024, 0x10000005, 0x3442251f, 0x8f820214, 0x3c03ffff, 0x431024, 0x3442241f, 0xaf820214, +0x8f820220, 0x3c03f700, 0x431025, 0xaf820220, 0x8f820220, 0x3c030200, 0x34420002, 0xaf820220, 0x24020008, 0xaee204b8, 0x8f820220, 0x283a025, 0x3c030004, 0x431024, 0x14400016, 0x0, -0x3c020002, 0x8c4290bc, 0x30425000, 0x1040000d, +0x3c020002, 0x8c42a71c, 0x30425000, 0x1040000d, 0x0, 0x8f820220, 0x30428000, 0x10400006, 0x0, 0x8f820220, 0x3c03ffff, 0x34637fff, 0x10000003, 0x431024, 0x8f820220, 0x34428000, 0xaf820220, 0x8f820220, 0x3c03f700, 0x431025, -0xaf820220, 0x3c030001, 0x8c637000, 0x24020005, -0x1462000a, 0x0, 0x3c020001, 0x94426fe6, +0xaf820220, 0x3c030002, 0x8c638660, 0x24020005, +0x1462000a, 0x0, 0x3c020002, 0x94428646, 0x24429fbc, 0x2c420004, 0x10400004, 0x24040018, -0x24050002, 0xc004e0b, 0x24060020, 0xc003e69, -0x0, 0x3c010001, 0x1000018a, 0xac206ee0, -0x8ee204b8, 0x2443ffff, 0x2c620008, 0x10400185, -0x31080, 0x3c010001, 0x220821, 0x8c226be0, -0x400008, 0x0, 0xc003dab, 0x0, -0x3c010001, 0xac206e5c, 0xaf800204, 0x3c010002, -0xc0044b5, 0xac2090a0, 0x24020001, 0x3c010001, -0xac226e74, 0x1000010a, 0x24020002, 0xc00457a, -0x0, 0x3c030001, 0x8c636e74, 0x100000d2, -0x24020009, 0x3c020002, 0x8c4290b8, 0x30424000, -0x10400004, 0x0, 0x8f820044, 0x10000006, -0x3442f080, 0x8f820044, 0x3c03ffff, 0x34633f7f, -0x431024, 0x3442a080, 0xaf820044, 0x8f830054, -0x100000f7, 0x24020004, 0x8f830054, 0x3c020001, -0x8c426fe8, 0x2463d8f0, 0x431023, 0x2c422710, -0x14400154, 0x24020005, 0x100000c2, 0x0, -0x8f820220, 0x3c03f700, 0x431025, 0xaf820220, -0xaf800204, 0x3c010002, 0x100000e3, 0xac2090a0, -0x8f830054, 0x3c020001, 0x8c426fe8, 0x2463fff6, -0x431023, 0x2c42000a, 0x14400142, 0x24020007, -0x100000e4, 0x0, 0xc003f4c, 0x0, -0x1040013a, 0x24020001, 0x8f820214, 0x3c03ffff, -0x3c040001, 0x8c846fdc, 0x431024, 0x3442241f, -0xaf820214, 0x24020008, 0x10800005, 0xaee204b8, -0x3c020001, 0x8c426f04, 0x1040004e, 0x24020001, -0x8f820220, 0x3c030008, 0x431024, 0x10400054, -0x3c020200, 0x10000062, 0x0, 0x8ee204b8, -0x2443ffff, 0x2c620007, 0x10400122, 0x31080, -0x3c010001, 0x220821, 0x8c226c00, 0x400008, -0x0, 0xc00457a, 0x0, 0x3c030001, -0x8c636e74, 0x1000007c, 0x24020009, 0x3c020002, -0x8c4290b8, 0x30424000, 0x10400003, 0x3c0200c8, -0x10000002, 0x344201f6, 0x344201fe, 0xaf820238, -0x8f830054, 0x100000a6, 0x24020004, 0x8f830054, -0x3c020001, 0x8c426fe8, 0x2463d8f0, 0x431023, -0x2c422710, 0x14400103, 0x24020005, 0x10000071, -0x0, 0x8f830054, 0x3c020001, 0x8c426fe8, -0x2463fff6, 0x431023, 0x2c42000a, 0x144000f9, -0x24020007, 0x1000009b, 0x0, 0xc003f4c, -0x0, 0x104000f1, 0x24020001, 0x8f820214, -0x3c03ffff, 0x3c040001, 0x8c846fdc, 0x431024, -0x3442241f, 0xaf820214, 0x24020008, 0x1080000f, -0xaee204b8, 0x3c020001, 0x8c426f04, 0x1440000b, -0x0, 0x8f820220, 0x34420002, 0xaf820220, -0x24020001, 0x3c010002, 0xac229050, 0xc004ecc, -0x8f840220, 0x10000016, 0x0, 0x8f820220, -0x3c030008, 0x431024, 0x14400011, 0x3c020200, -0x282a025, 0x2402000e, 0x3c010002, 0xac229050, -0xc00554b, 0x2021, 0x8f820220, 0x34420002, -0xc003e69, 0xaf820220, 0x3c050001, 0x8ca56e58, -0xc0052cb, 0x2021, 0x100000c6, 0x0, -0x3c020001, 0x8c426f04, 0x104000c2, 0x0, -0x3c020001, 0x8c426f00, 0x2442ffff, 0x3c010001, -0xac226f00, 0x144000bb, 0x24020002, 0x3c010001, -0xac206f04, 0x3c010001, 0x100000b6, 0xac226f00, -0x8ee204b8, 0x2443ffff, 0x2c620007, 0x104000b1, -0x31080, 0x3c010001, 0x220821, 0x8c226c20, -0x400008, 0x0, 0x3c020001, 0x8c426e64, -0x10400018, 0x24020005, 0xc0044b5, 0x0, -0x24020002, 0xaee204b8, 0x3c010001, 0x100000a1, -0xac206e64, 0xc004993, 0x0, 0x3c030001, -0x8c636e94, 0x24020006, 0x1462009a, 0x24020003, -0x10000098, 0xaee204b8, 0x3c050001, 0x8ca56e58, -0x3c060002, 0x8cc690b8, 0xc005134, 0x2021, -0x24020005, 0x1000008f, 0xaee204b8, 0x24040001, -0x2405001a, 0x8f820220, 0x27a60018, 0x3c03f700, -0x431025, 0xc0045ac, 0xaf820220, 0x97a60018, -0x30c20200, 0x1040001c, 0x3c05000c, 0x3c040001, -0x24846bb8, 0x34a50112, 0x3c020001, 0x8c426e58, -0x3c030001, 0x8c636fdc, 0x3821, 0xafa20010, -0xc002b37, 0xafa30014, 0x2021, 0x2821, -0xc004e0b, 0x24064040, 0x3c020001, 0x8c426fdc, -0x10400006, 0x2021, 0x2821, 0xc004e0b, -0x24061000, 0x1000006b, 0x0, 0x24020002, -0x10000068, 0xaee204b8, 0x8f830054, 0x24020006, -0xaee204b8, 0x3c010001, 0x10000062, 0xac236fe8, +0x24050002, 0xc0053b9, 0x24060020, 0xc004401, +0x0, 0x3c010002, 0xac20854c, 0x10000192, +0x0, 0x8ee204b8, 0x2443ffff, 0x2c620008, +0x1040018d, 0x31080, 0x3c010002, 0x220821, +0x8c228068, 0x400008, 0x0, 0xc004343, +0x0, 0x3c010002, 0xac2084d0, 0xaf800204, +0x3c010002, 0xac20a700, 0xc004ab2, 0x0, +0x24020001, 0x3c010002, 0xac2284e8, 0x1000010f, +0x24020002, 0xc004b7b, 0x0, 0x3c030002, +0x8c6384e8, 0x100000d6, 0x24020009, 0x3c020002, +0x8c42a718, 0x30424000, 0x10400004, 0x0, +0x8f820044, 0x10000006, 0x3442f080, 0x8f820044, +0x3c03ffff, 0x34633f7f, 0x431024, 0x3442a080, +0xaf820044, 0x8f830054, 0x100000fc, 0x24020004, +0x8f830054, 0x3c020002, 0x8c428648, 0x2463d8f0, +0x431023, 0x2c422711, 0x1440015b, 0x24020005, +0x100000c6, 0x0, 0x8f820220, 0x3c03f700, +0x431025, 0xaf820220, 0xaf800204, 0x3c010002, +0xac20a700, 0x100000e7, 0x0, 0x8f830054, +0x3c020002, 0x8c428648, 0x2463fff6, 0x431023, +0x2c42000b, 0x14400148, 0x24020007, 0x100000e9, +0x0, 0xc0044e0, 0x0, 0x10400140, +0x24020001, 0x8f820214, 0x3c03ffff, 0x3c040002, +0x8c84863c, 0x431024, 0x3442241f, 0xaf820214, +0x24020008, 0x10800005, 0xaee204b8, 0x3c020002, +0x8c428568, 0x1040004e, 0x24020001, 0x8f820220, +0x3c030008, 0x431024, 0x10400054, 0x3c020200, +0x10000063, 0x0, 0x8ee204b8, 0x2443ffff, +0x2c620007, 0x10400128, 0x31080, 0x3c010002, +0x220821, 0x8c228088, 0x400008, 0x0, +0xc004b7b, 0x0, 0x3c030002, 0x8c6384e8, +0x1000007f, 0x24020009, 0x3c020002, 0x8c42a718, +0x30424000, 0x10400003, 0x3c0200c8, 0x10000002, +0x344201f6, 0x344201fe, 0xaf820238, 0x8f830054, +0x100000aa, 0x24020004, 0x8f830054, 0x3c020002, +0x8c428648, 0x2463d8f0, 0x431023, 0x2c422711, +0x14400109, 0x24020005, 0x10000074, 0x0, +0x8f830054, 0x3c020002, 0x8c428648, 0x2463fff6, +0x431023, 0x2c42000b, 0x144000ff, 0x24020007, +0x100000a0, 0x0, 0xc0044e0, 0x0, +0x104000f7, 0x24020001, 0x8f820214, 0x3c03ffff, +0x3c040002, 0x8c84863c, 0x431024, 0x3442241f, +0xaf820214, 0x24020008, 0x1080000f, 0xaee204b8, +0x3c020002, 0x8c428568, 0x1440000b, 0x0, +0x8f820220, 0x34420002, 0xaf820220, 0x24020001, +0x3c010002, 0xac22a6b0, 0xc005477, 0x8f840220, +0x10000017, 0x0, 0x8f820220, 0x3c030008, +0x431024, 0x14400012, 0x3c020200, 0x282a025, +0x2402000e, 0x3c010002, 0xac22a6b0, 0xc005ae7, +0x2021, 0x8f820220, 0x34420002, 0xaf820220, +0xc004401, 0x0, 0x3c050002, 0x8ca584cc, +0xc005897, 0x2021, 0x100000cb, 0x0, +0x3c020002, 0x8c428568, 0x104000c7, 0x0, +0x3c020002, 0x8c428564, 0x2442ffff, 0x3c010002, +0xac228564, 0x144000c0, 0x24020002, 0x3c010002, +0xac208568, 0x3c010002, 0xac228564, 0x100000ba, +0x0, 0x8ee204b8, 0x2443ffff, 0x2c620007, +0x104000b5, 0x31080, 0x3c010002, 0x220821, +0x8c2280a8, 0x400008, 0x0, 0x3c020002, +0x8c4284d8, 0x10400019, 0x24020005, 0xc004ab2, +0x0, 0x24020002, 0xaee204b8, 0x3c010002, +0xac2084d8, 0x100000a4, 0x0, 0xc004fe6, +0x0, 0x3c030002, 0x8c638500, 0x24020006, +0x1462009d, 0x24020003, 0x1000009b, 0xaee204b8, +0x3c050002, 0x8ca584cc, 0x3c060002, 0x8cc6a718, +0xc0056f1, 0x2021, 0x24020005, 0x10000092, +0xaee204b8, 0x24040001, 0x2405001a, 0x8f820220, +0x27a60018, 0x3c03f700, 0x431025, 0xaf820220, +0xc004bf8, 0x0, 0x97a60018, 0x30c20200, +0x1040001c, 0x3c05000c, 0x3c040002, 0x24848040, +0x34a50112, 0x3c020002, 0x8c4284cc, 0x3c030002, +0x8c63863c, 0x3821, 0xafa20010, 0xc002d3b, +0xafa30014, 0x2021, 0x2821, 0xc0053b9, +0x24064040, 0x3c020002, 0x8c42863c, 0x10400006, +0x2021, 0x2821, 0xc0053b9, 0x24061000, +0x1000006d, 0x0, 0x24020002, 0x1000006a, +0xaee204b8, 0x8f830054, 0x24020006, 0xaee204b8, +0x3c010002, 0xac238648, 0x10000063, 0x0, 0x8f820220, 0x3c030004, 0x431024, 0x10400003, -0x24020007, 0x1000005b, 0xaee204b8, 0x8f830054, -0x3c020001, 0x8c426fe8, 0x2463d8f0, 0x431023, -0x2c422710, 0x14400003, 0x24020001, 0x3c010001, -0xac226e5c, 0x3c020002, 0x8c4290b8, 0x30425000, -0x1040004c, 0x0, 0x8f820220, 0x30428000, +0x24020007, 0x1000005c, 0xaee204b8, 0x8f830054, +0x3c020002, 0x8c428648, 0x2463d8f0, 0x431023, +0x2c422710, 0x14400003, 0x24020001, 0x3c010002, +0xac2284d0, 0x3c020002, 0x8c42a718, 0x30425000, +0x1040004d, 0x0, 0x8f820220, 0x30428000, 0x10400007, 0x0, 0x8f820220, 0x3c03ffff, -0x34637fff, 0x431024, 0x10000042, 0xaf820220, -0x8f820220, 0x34428000, 0x1000003e, 0xaf820220, -0x3c050001, 0x8ca56e58, 0xc0052cb, 0x2021, -0xc00554b, 0x2021, 0x3c020002, 0x8c4290b0, -0x4410032, 0x24020001, 0x8f820214, 0x3c03ffff, -0x431024, 0x3442241f, 0xaf820214, 0x24020008, -0xaee204b8, 0x8f820220, 0x34420002, 0xaf820220, -0x8f820220, 0x3c030004, 0x431024, 0x14400016, -0x0, 0x3c020002, 0x8c4290b8, 0x30425000, -0x1040000d, 0x0, 0x8f820220, 0x30428000, -0x10400006, 0x0, 0x8f820220, 0x3c03ffff, -0x34637fff, 0x10000003, 0x431024, 0x8f820220, -0x34428000, 0xaf820220, 0x8f820220, 0x3c03f700, -0x431025, 0xaf820220, 0x3c020001, 0x94426fe6, -0x24429fbc, 0x2c420004, 0x10400004, 0x24040018, -0x24050002, 0xc004e0b, 0x24060020, 0xc003e69, -0x0, 0x10000003, 0x0, 0x3c010001, -0xac226e5c, 0x8fbf0020, 0x3e00008, 0x27bd0028, -0x8f820200, 0x8f820220, 0x8f820220, 0x34420004, -0xaf820220, 0x8f820200, 0x3c050001, 0x8ca56e58, -0x34420004, 0xaf820200, 0x24020002, 0x10a2004b, -0x2ca20003, 0x10400005, 0x24020001, 0x10a2000a, -0x0, 0x100000b1, 0x0, 0x24020004, -0x10a20072, 0x24020008, 0x10a20085, 0x3c02f0ff, -0x100000aa, 0x0, 0x8f830050, 0x3c02f0ff, -0x3442ffff, 0x3c040001, 0x8c847000, 0x621824, -0x3c020700, 0x621825, 0x24020e00, 0x2484fffb, -0x2c840002, 0xaf830050, 0xaf850200, 0xaf850220, -0x14800006, 0xaf820238, 0x8f820044, 0x3c03ffff, -0x34633f7f, 0x431024, 0xaf820044, 0x3c030001, -0x8c637000, 0x24020005, 0x14620004, 0x0, -0x8f820044, 0x34425000, 0xaf820044, 0x3c020001, -0x8c426e48, 0x3c030001, 0x8c637000, 0x34420022, -0x2463fffc, 0x2c630002, 0x1460000c, 0xaf820200, -0x3c020001, 0x8c426e6c, 0x3c030001, 0x8c636e50, -0x3c040001, 0x8c846e4c, 0x34428000, 0x621825, -0x641825, 0x1000000a, 0x34620002, 0x3c020001, -0x8c426e50, 0x3c030001, 0x8c636e6c, 0x3c040001, -0x8c846e4c, 0x431025, 0x441025, 0x34420002, -0xaf820220, 0x1000002f, 0x24020001, 0x24020e01, -0xaf820238, 0x8f830050, 0x3c02f0ff, 0x3442ffff, -0x3c040001, 0x8c846fdc, 0x621824, 0x3c020d00, -0x621825, 0x24020001, 0xaf830050, 0xaf820200, -0xaf820220, 0x10800005, 0x3c033f00, 0x3c020001, -0x8c426e40, 0x10000004, 0x34630070, 0x3c020001, -0x8c426e40, 0x34630072, 0x431025, 0xaf820200, -0x3c030001, 0x8c636e44, 0x3c02f700, 0x621825, -0x3c020001, 0x8c426e50, 0x3c040001, 0x8c846e6c, -0x3c050001, 0x8ca57000, 0x431025, 0x441025, -0xaf820220, 0x24020005, 0x14a20006, 0x24020001, -0x8f820044, 0x2403afff, 0x431024, 0xaf820044, -0x24020001, 0x1000003d, 0xaf820238, 0x8f830050, -0x3c02f0ff, 0x3442ffff, 0x3c040001, 0x8c846fdc, -0x621824, 0x3c020a00, 0x621825, 0x24020001, -0xaf830050, 0xaf820200, 0x1080001e, 0xaf820220, -0x3c020001, 0x8c426f04, 0x1440001a, 0x3c033f00, -0x3c020001, 0x8c426e40, 0x1000001a, 0x346300e0, -0x8f830050, 0x3c040001, 0x8c846fdc, 0x3442ffff, -0x621824, 0x1080000f, 0xaf830050, 0x3c020001, -0x8c426f04, 0x1440000b, 0x3c043f00, 0x3c030001, -0x8c636e40, 0x348400e0, 0x24020001, 0xaf820200, -0xaf820220, 0x641825, 0xaf830200, 0x10000008, -0x3c05f700, 0x3c020001, 0x8c426e40, 0x3c033f00, -0x346300e2, 0x431025, 0xaf820200, 0x3c05f700, -0x34a58000, 0x3c030001, 0x8c636e44, 0x3c020001, -0x8c426e50, 0x3c040001, 0x8c846e6c, 0x651825, -0x431025, 0x441025, 0xaf820220, 0x3e00008, -0x0, 0x3c030001, 0x8c636e74, 0x3c020001, -0x8c426e78, 0x10620003, 0x24020002, 0x3c010001, -0xac236e78, 0x1062001d, 0x2c620003, 0x10400025, -0x24020001, 0x14620023, 0x24020004, 0x3c030001, -0x8c636e58, 0x10620006, 0x24020008, 0x1462000c, -0x3c0200c8, 0x344201fb, 0x10000009, 0xaf820238, +0x34637fff, 0x431024, 0x10000043, 0xaf820220, +0x8f820220, 0x34428000, 0xaf820220, 0x1000003e, +0x0, 0x3c050002, 0x8ca584cc, 0xc005897, +0x2021, 0xc005ae7, 0x2021, 0x3c020002, +0x8c42a710, 0x4410032, 0x24020001, 0x8f820214, +0x3c03ffff, 0x431024, 0x3442241f, 0xaf820214, +0x24020008, 0xaee204b8, 0x8f820220, 0x34420002, +0xaf820220, 0x8f820220, 0x3c030004, 0x431024, +0x14400016, 0x0, 0x3c020002, 0x8c42a718, +0x30425000, 0x1040000d, 0x0, 0x8f820220, +0x30428000, 0x10400006, 0x0, 0x8f820220, +0x3c03ffff, 0x34637fff, 0x10000003, 0x431024, +0x8f820220, 0x34428000, 0xaf820220, 0x8f820220, +0x3c03f700, 0x431025, 0xaf820220, 0x3c020002, +0x94428646, 0x24429fbc, 0x2c420004, 0x10400004, +0x24040018, 0x24050002, 0xc0053b9, 0x24060020, +0xc004401, 0x0, 0x10000003, 0x0, +0x3c010002, 0xac2284d0, 0x8fbf0020, 0x3e00008, +0x27bd0028, 0x8f820200, 0x8f820220, 0x8f820220, +0x34420004, 0xaf820220, 0x8f820200, 0x3c050002, +0x8ca584cc, 0x34420004, 0xaf820200, 0x24020002, +0x10a2004c, 0x2ca20003, 0x10400005, 0x24020001, +0x10a2000a, 0x0, 0x100000b5, 0x0, +0x24020004, 0x10a20074, 0x24020008, 0x10a20088, +0x3c02f0ff, 0x100000ae, 0x0, 0x8f830050, +0x3c02f0ff, 0x3442ffff, 0x3c040002, 0x8c848660, +0x621824, 0x3c020700, 0x621825, 0x24020e00, +0x2484fffb, 0x2c840002, 0xaf830050, 0xaf850200, +0xaf850220, 0xaf820238, 0x14800006, 0x0, +0x8f820044, 0x3c03ffff, 0x34633f7f, 0x431024, +0xaf820044, 0x3c030002, 0x8c638660, 0x24020005, +0x14620004, 0x0, 0x8f820044, 0x34425000, +0xaf820044, 0x3c020002, 0x8c4284bc, 0x3c030002, +0x8c638660, 0x34420022, 0x2463fffc, 0x2c630002, +0xaf820200, 0x1460000a, 0x3c05f700, 0x34a50002, +0x3c030002, 0x8c6384e0, 0x3c020002, 0x8c4284c4, +0x3c040002, 0x8c8484c0, 0x10000008, 0x34638000, +0x3c020002, 0x8c4284c4, 0x3c030002, 0x8c6384e0, +0x3c040002, 0x8c8484c0, 0x34a50002, 0x431025, +0x441025, 0x451025, 0xaf820220, 0x1000002f, +0x24020001, 0x24020e01, 0xaf820238, 0x8f830050, +0x3c02f0ff, 0x3442ffff, 0x3c040002, 0x8c84863c, +0x621824, 0x3c020d00, 0x621825, 0x24020001, +0xaf830050, 0xaf820200, 0xaf820220, 0x10800005, +0x3c033f00, 0x3c020002, 0x8c4284b4, 0x10000004, +0x34630070, 0x3c020002, 0x8c4284b4, 0x34630072, +0x431025, 0xaf820200, 0x3c030002, 0x8c6384b8, +0x3c02f700, 0x621825, 0x3c020002, 0x8c4284c4, +0x3c040002, 0x8c8484e0, 0x3c050002, 0x8ca58660, +0x431025, 0x441025, 0xaf820220, 0x24020005, +0x14a20006, 0x24020001, 0x8f820044, 0x2403afff, +0x431024, 0xaf820044, 0x24020001, 0xaf820238, +0x1000003f, 0x0, 0x8f830050, 0x3c02f0ff, +0x3442ffff, 0x3c040002, 0x8c84863c, 0x621824, +0x3c020a00, 0x621825, 0x24020001, 0xaf830050, +0xaf820200, 0xaf820220, 0x1080001f, 0x0, +0x3c020002, 0x8c428568, 0x1440001b, 0x3c033f00, +0x3c020002, 0x8c4284b4, 0x1000001b, 0x346300e0, +0x8f830050, 0x3c040002, 0x8c84863c, 0x3442ffff, +0x621824, 0xaf830050, 0x1080000f, 0x0, +0x3c020002, 0x8c428568, 0x1440000b, 0x3c043f00, +0x3c030002, 0x8c6384b4, 0x348400e0, 0x24020001, +0xaf820200, 0xaf820220, 0x641825, 0xaf830200, +0x10000008, 0x3c05f700, 0x3c020002, 0x8c4284b4, +0x3c033f00, 0x346300e2, 0x431025, 0xaf820200, +0x3c05f700, 0x34a58000, 0x3c030002, 0x8c6384b8, +0x3c020002, 0x8c4284c4, 0x3c040002, 0x8c8484e0, +0x651825, 0x431025, 0x441025, 0xaf820220, +0x3e00008, 0x0, 0x3c030002, 0x8c6384e8, +0x3c020002, 0x8c4284ec, 0x27bdffe0, 0x10620003, +0xafbf0018, 0x3c010002, 0xac2384ec, 0x24020002, +0x1062003c, 0x2c620003, 0x10400005, 0x24020001, +0x10620008, 0x24020004, 0x10000055, 0x0, +0x24020009, 0x1062003f, 0x24020a21, 0x10000050, +0x0, 0x3c030002, 0x8c6384cc, 0x10620008, +0x24020008, 0x14620010, 0x24020a08, 0x3c0200c8, +0x344201fb, 0xaf820238, 0x1000001e, 0x0, 0x24020e01, 0xaf820238, 0x8f820044, 0x3c03ffff, 0x34633f7f, 0x431024, 0x34420080, 0xaf820044, -0x8f830054, 0x24020002, 0x3c010001, 0xac226e74, -0x3c010001, 0x1000000b, 0xac236fec, 0x8f830054, -0x3c020001, 0x8c426fec, 0x2463d8f0, 0x431023, -0x2c422710, 0x14400003, 0x24020009, 0x3c010001, -0xac226e74, 0x3e00008, 0x0, 0x27bdffd8, +0x10000014, 0x0, 0x3c040001, 0x24847ff8, +0xafa20010, 0xafa00014, 0x8f860144, 0x3c070002, +0x24e78010, 0xc002d3b, 0x3405dead, 0x8f82011c, +0x34420002, 0xaf82011c, 0x8f820220, 0x34420004, +0xaf820220, 0x8f820140, 0x3c030001, 0x431025, +0xaf820140, 0x8f830054, 0x24020002, 0x3c010002, +0xac2284e8, 0x3c010002, 0xac23864c, 0x10000034, +0x0, 0x8f830054, 0x3c020002, 0x8c42864c, +0x2463d8f0, 0x431023, 0x2c422710, 0x1440002c, +0x24020009, 0x3c010002, 0xac2284e8, 0x10000028, +0x0, 0x3c040001, 0x24847ff8, 0xafa20010, +0xafa00014, 0x8f860144, 0x3c070002, 0x24e78010, +0xc002d3b, 0x3405dead, 0x8f82011c, 0x34420002, +0xaf82011c, 0x8f820220, 0x34420004, 0xaf820220, +0x8f820140, 0x3c030001, 0x431025, 0xaf820140, +0x3c040001, 0x24847ff8, 0x24020a27, 0xafa20010, +0xafa00014, 0x8f860144, 0x3c070002, 0x24e78010, +0xc002d3b, 0x3405dead, 0x8f82011c, 0x34420002, +0xaf82011c, 0x8f820220, 0x34420004, 0xaf820220, +0x8f820140, 0x3c030001, 0x431025, 0xaf820140, +0x8fbf0018, 0x3e00008, 0x27bd0020, 0x27bdffd8, 0xafb20018, 0x809021, 0xafb3001c, 0xa09821, 0xafb10014, 0xc08821, 0xafb00010, 0x8021, -0xafbf0020, 0xa6200000, 0xc004da8, 0x24040001, +0xafbf0020, 0xa6200000, 0xc00538f, 0x24040001, 0x26100001, 0x2e020020, 0x1440fffb, 0x0, -0xc004da8, 0x2021, 0xc004da8, 0x24040001, -0xc004da8, 0x24040001, 0xc004da8, 0x2021, +0xc00538f, 0x2021, 0xc00538f, 0x24040001, +0xc00538f, 0x24040001, 0xc00538f, 0x2021, 0x24100010, 0x2501024, 0x10400002, 0x2021, -0x24040001, 0xc004da8, 0x108042, 0x1600fffa, +0x24040001, 0xc00538f, 0x108042, 0x1600fffa, 0x2501024, 0x24100010, 0x2701024, 0x10400002, -0x2021, 0x24040001, 0xc004da8, 0x108042, -0x1600fffa, 0x2701024, 0xc004de9, 0x34108000, -0xc004de9, 0x0, 0xc004d88, 0x0, +0x2021, 0x24040001, 0xc00538f, 0x108042, +0x1600fffa, 0x2701024, 0xc0053aa, 0x34108000, +0xc0053aa, 0x0, 0xc005382, 0x0, 0x50400005, 0x108042, 0x96220000, 0x501025, 0xa6220000, 0x108042, 0x1600fff7, 0x0, -0xc004de9, 0x0, 0x8fbf0020, 0x8fb3001c, +0xc0053aa, 0x0, 0x8fbf0020, 0x8fb3001c, 0x8fb20018, 0x8fb10014, 0x8fb00010, 0x3e00008, 0x27bd0028, 0x27bdffd8, 0xafb10014, 0x808821, 0xafb20018, 0xa09021, 0xafb3001c, 0xc09821, -0xafb00010, 0x8021, 0xafbf0020, 0xc004da8, +0xafb00010, 0x8021, 0xafbf0020, 0xc00538f, 0x24040001, 0x26100001, 0x2e020020, 0x1440fffb, -0x0, 0xc004da8, 0x2021, 0xc004da8, -0x24040001, 0xc004da8, 0x2021, 0xc004da8, +0x0, 0xc00538f, 0x2021, 0xc00538f, +0x24040001, 0xc00538f, 0x2021, 0xc00538f, 0x24040001, 0x24100010, 0x2301024, 0x10400002, -0x2021, 0x24040001, 0xc004da8, 0x108042, +0x2021, 0x24040001, 0xc00538f, 0x108042, 0x1600fffa, 0x2301024, 0x24100010, 0x2501024, -0x10400002, 0x2021, 0x24040001, 0xc004da8, -0x108042, 0x1600fffa, 0x2501024, 0xc004da8, -0x24040001, 0xc004da8, 0x2021, 0x34108000, +0x10400002, 0x2021, 0x24040001, 0xc00538f, +0x108042, 0x1600fffa, 0x2501024, 0xc00538f, +0x24040001, 0xc00538f, 0x2021, 0x34108000, 0x96620000, 0x501024, 0x10400002, 0x2021, -0x24040001, 0xc004da8, 0x108042, 0x1600fff8, -0x0, 0xc004de9, 0x0, 0x8fbf0020, +0x24040001, 0xc00538f, 0x108042, 0x1600fff8, +0x0, 0xc0053aa, 0x0, 0x8fbf0020, 0x8fb3001c, 0x8fb20018, 0x8fb10014, 0x8fb00010, -0x3e00008, 0x27bd0028, 0x3c040001, 0x8c846e90, -0x3c020001, 0x8c426ed8, 0x27bdffd8, 0xafbf0020, -0xafb1001c, 0x10820003, 0xafb00018, 0x3c010001, -0xac246ed8, 0x3c030001, 0x8c637000, 0x24020005, -0x14620005, 0x2483ffff, 0xc004993, 0x0, -0x1000034c, 0x0, 0x2c620013, 0x10400349, -0x31080, 0x3c010001, 0x220821, 0x8c226c40, -0x400008, 0x0, 0xc004de9, 0x8021, -0x34028000, 0xa7a20010, 0x27b10010, 0xc004da8, +0x3e00008, 0x27bd0028, 0x3c040002, 0x8c8484fc, +0x3c020002, 0x8c428544, 0x27bdffd8, 0xafbf0020, +0xafb1001c, 0x10820003, 0xafb00018, 0x3c010002, +0xac248544, 0x3c030002, 0x8c638660, 0x24020005, +0x14620005, 0x2483ffff, 0xc004fe6, 0x0, +0x10000353, 0x0, 0x2c620013, 0x10400350, +0x31080, 0x3c010002, 0x220821, 0x8c2280e0, +0x400008, 0x0, 0xc0053aa, 0x8021, +0x34028000, 0xa7a20010, 0x27b10010, 0xc00538f, 0x24040001, 0x26100001, 0x2e020020, 0x1440fffb, -0x0, 0xc004da8, 0x2021, 0xc004da8, -0x24040001, 0xc004da8, 0x2021, 0xc004da8, +0x0, 0xc00538f, 0x2021, 0xc00538f, +0x24040001, 0xc00538f, 0x2021, 0xc00538f, 0x24040001, 0x24100010, 0x32020001, 0x10400002, -0x2021, 0x24040001, 0xc004da8, 0x108042, -0x1600fffa, 0x32020001, 0x24100010, 0xc004da8, +0x2021, 0x24040001, 0xc00538f, 0x108042, +0x1600fffa, 0x32020001, 0x24100010, 0xc00538f, 0x2021, 0x108042, 0x1600fffc, 0x0, -0xc004da8, 0x24040001, 0xc004da8, 0x2021, +0xc00538f, 0x24040001, 0xc00538f, 0x2021, 0x34108000, 0x96220000, 0x501024, 0x10400002, -0x2021, 0x24040001, 0xc004da8, 0x108042, -0x1600fff8, 0x0, 0xc004de9, 0x0, -0x1000030e, 0x24020002, 0x27b10010, 0xa7a00010, -0x8021, 0xc004da8, 0x24040001, 0x26100001, -0x2e020020, 0x1440fffb, 0x0, 0xc004da8, -0x2021, 0xc004da8, 0x24040001, 0xc004da8, -0x24040001, 0xc004da8, 0x2021, 0x24100010, +0x2021, 0x24040001, 0xc00538f, 0x108042, +0x1600fff8, 0x0, 0xc0053aa, 0x0, +0x10000315, 0x24020002, 0x27b10010, 0xa7a00010, +0x8021, 0xc00538f, 0x24040001, 0x26100001, +0x2e020020, 0x1440fffb, 0x0, 0xc00538f, +0x2021, 0xc00538f, 0x24040001, 0xc00538f, +0x24040001, 0xc00538f, 0x2021, 0x24100010, 0x32020001, 0x10400002, 0x2021, 0x24040001, -0xc004da8, 0x108042, 0x1600fffa, 0x32020001, -0x24100010, 0xc004da8, 0x2021, 0x108042, -0x1600fffc, 0x0, 0xc004de9, 0x34108000, -0xc004de9, 0x0, 0xc004d88, 0x0, +0xc00538f, 0x108042, 0x1600fffa, 0x32020001, +0x24100010, 0xc00538f, 0x2021, 0x108042, +0x1600fffc, 0x0, 0xc0053aa, 0x34108000, +0xc0053aa, 0x0, 0xc005382, 0x0, 0x50400005, 0x108042, 0x96220000, 0x501025, 0xa6220000, 0x108042, 0x1600fff7, 0x0, -0xc004de9, 0x0, 0x97a20010, 0x30428000, -0x144002dc, 0x24020003, 0x100002d8, 0x0, +0xc0053aa, 0x0, 0x97a20010, 0x30428000, +0x144002e3, 0x24020003, 0x100002df, 0x0, 0x24021200, 0xa7a20010, 0x27b10010, 0x8021, -0xc004da8, 0x24040001, 0x26100001, 0x2e020020, -0x1440fffb, 0x0, 0xc004da8, 0x2021, -0xc004da8, 0x24040001, 0xc004da8, 0x2021, -0xc004da8, 0x24040001, 0x24100010, 0x32020001, -0x10400002, 0x2021, 0x24040001, 0xc004da8, +0xc00538f, 0x24040001, 0x26100001, 0x2e020020, +0x1440fffb, 0x0, 0xc00538f, 0x2021, +0xc00538f, 0x24040001, 0xc00538f, 0x2021, +0xc00538f, 0x24040001, 0x24100010, 0x32020001, +0x10400002, 0x2021, 0x24040001, 0xc00538f, 0x108042, 0x1600fffa, 0x32020001, 0x24100010, -0xc004da8, 0x2021, 0x108042, 0x1600fffc, -0x0, 0xc004da8, 0x24040001, 0xc004da8, +0xc00538f, 0x2021, 0x108042, 0x1600fffc, +0x0, 0xc00538f, 0x24040001, 0xc00538f, 0x2021, 0x34108000, 0x96220000, 0x501024, -0x10400002, 0x2021, 0x24040001, 0xc004da8, -0x108042, 0x1600fff8, 0x0, 0xc004de9, -0x0, 0x8f830054, 0x10000296, 0x24020004, -0x8f830054, 0x3c020001, 0x8c426ffc, 0x2463ff9c, -0x431023, 0x2c420064, 0x1440029e, 0x24020002, -0x3c030001, 0x8c637000, 0x10620297, 0x2c620003, -0x14400296, 0x24020011, 0x24020003, 0x10620005, -0x24020004, 0x10620291, 0x2402000f, 0x1000028f, -0x24020011, 0x1000028d, 0x24020005, 0x24020014, -0xa7a20010, 0x27b10010, 0x8021, 0xc004da8, +0x10400002, 0x2021, 0x24040001, 0xc00538f, +0x108042, 0x1600fff8, 0x0, 0xc0053aa, +0x0, 0x8f830054, 0x1000029c, 0x24020004, +0x8f830054, 0x3c020002, 0x8c42865c, 0x2463ff9c, +0x431023, 0x2c420064, 0x144002a5, 0x0, +0x3c020002, 0x8c428660, 0x2443ffff, 0x2c620007, +0x1040029c, 0x31080, 0x3c010002, 0x220821, +0x8c228130, 0x400008, 0x0, 0x10000296, +0x24020005, 0x10000294, 0x2402000f, 0x24020034, +0xa7a20010, 0x27b10010, 0x8021, 0xc00538f, 0x24040001, 0x26100001, 0x2e020020, 0x1440fffb, -0x0, 0xc004da8, 0x2021, 0xc004da8, -0x24040001, 0xc004da8, 0x2021, 0xc004da8, +0x0, 0xc00538f, 0x2021, 0xc00538f, +0x24040001, 0xc00538f, 0x2021, 0xc00538f, 0x24040001, 0x24100010, 0x32020001, 0x10400002, -0x2021, 0x24040001, 0xc004da8, 0x108042, +0x2021, 0x24040001, 0xc00538f, 0x108042, 0x1600fffa, 0x32020001, 0x24100010, 0x32020012, -0x10400002, 0x2021, 0x24040001, 0xc004da8, -0x108042, 0x1600fffa, 0x32020012, 0xc004da8, -0x24040001, 0xc004da8, 0x2021, 0x34108000, -0x96220000, 0x501024, 0x10400002, 0x2021, -0x24040001, 0xc004da8, 0x108042, 0x1600fff8, -0x0, 0xc004de9, 0x0, 0x8f830054, -0x10000248, 0x24020006, 0x8f830054, 0x3c020001, -0x8c426ffc, 0x2463ff9c, 0x431023, 0x2c420064, -0x14400250, 0x24020007, 0x1000024c, 0x0, -0x24020006, 0xa7a20010, 0x27b10010, 0x8021, -0xc004da8, 0x24040001, 0x26100001, 0x2e020020, -0x1440fffb, 0x0, 0xc004da8, 0x2021, -0xc004da8, 0x24040001, 0xc004da8, 0x2021, -0xc004da8, 0x24040001, 0x24100010, 0x32020001, -0x10400002, 0x2021, 0x24040001, 0xc004da8, -0x108042, 0x1600fffa, 0x32020001, 0x24100010, -0x32020013, 0x10400002, 0x2021, 0x24040001, -0xc004da8, 0x108042, 0x1600fffa, 0x32020013, -0xc004da8, 0x24040001, 0xc004da8, 0x2021, -0x34108000, 0x96220000, 0x501024, 0x10400002, -0x2021, 0x24040001, 0xc004da8, 0x108042, -0x1600fff8, 0x0, 0xc004de9, 0x0, -0x8f830054, 0x10000207, 0x24020008, 0x8f830054, -0x3c020001, 0x8c426ffc, 0x2463ff9c, 0x431023, -0x2c420064, 0x1440020f, 0x24020009, 0x1000020b, -0x0, 0x27b10010, 0xa7a00010, 0x8021, -0xc004da8, 0x24040001, 0x26100001, 0x2e020020, -0x1440fffb, 0x0, 0xc004da8, 0x2021, -0xc004da8, 0x24040001, 0xc004da8, 0x24040001, -0xc004da8, 0x2021, 0x24100010, 0x32020001, -0x10400002, 0x2021, 0x24040001, 0xc004da8, -0x108042, 0x1600fffa, 0x32020001, 0x24100010, -0x32020018, 0x10400002, 0x2021, 0x24040001, -0xc004da8, 0x108042, 0x1600fffa, 0x32020018, -0xc004de9, 0x34108000, 0xc004de9, 0x0, -0xc004d88, 0x0, 0x50400005, 0x108042, -0x96220000, 0x501025, 0xa6220000, 0x108042, -0x1600fff7, 0x0, 0xc004de9, 0x8021, -0x97a20010, 0x27b10010, 0x34420001, 0xa7a20010, -0xc004da8, 0x24040001, 0x26100001, 0x2e020020, -0x1440fffb, 0x0, 0xc004da8, 0x2021, -0xc004da8, 0x24040001, 0xc004da8, 0x2021, -0xc004da8, 0x24040001, 0x24100010, 0x32020001, -0x10400002, 0x2021, 0x24040001, 0xc004da8, -0x108042, 0x1600fffa, 0x32020001, 0x24100010, -0x32020018, 0x10400002, 0x2021, 0x24040001, -0xc004da8, 0x108042, 0x1600fffa, 0x32020018, -0xc004da8, 0x24040001, 0xc004da8, 0x2021, -0x34108000, 0x96220000, 0x501024, 0x10400002, -0x2021, 0x24040001, 0xc004da8, 0x108042, -0x1600fff8, 0x0, 0xc004de9, 0x0, -0x8f830054, 0x10000193, 0x2402000a, 0x8f830054, -0x3c020001, 0x8c426ffc, 0x2463ff9c, 0x431023, -0x2c420064, 0x1440019b, 0x2402000b, 0x10000197, -0x0, 0x27b10010, 0xa7a00010, 0x8021, -0xc004da8, 0x24040001, 0x26100001, 0x2e020020, -0x1440fffb, 0x0, 0xc004da8, 0x2021, -0xc004da8, 0x24040001, 0xc004da8, 0x24040001, -0xc004da8, 0x2021, 0x24100010, 0x32020001, -0x10400002, 0x2021, 0x24040001, 0xc004da8, -0x108042, 0x1600fffa, 0x32020001, 0x24100010, -0x32020017, 0x10400002, 0x2021, 0x24040001, -0xc004da8, 0x108042, 0x1600fffa, 0x32020017, -0xc004de9, 0x34108000, 0xc004de9, 0x0, -0xc004d88, 0x0, 0x50400005, 0x108042, -0x96220000, 0x501025, 0xa6220000, 0x108042, -0x1600fff7, 0x0, 0xc004de9, 0x8021, -0x97a20010, 0x27b10010, 0x34420700, 0xa7a20010, -0xc004da8, 0x24040001, 0x26100001, 0x2e020020, -0x1440fffb, 0x0, 0xc004da8, 0x2021, -0xc004da8, 0x24040001, 0xc004da8, 0x2021, -0xc004da8, 0x24040001, 0x24100010, 0x32020001, -0x10400002, 0x2021, 0x24040001, 0xc004da8, -0x108042, 0x1600fffa, 0x32020001, 0x24100010, -0x32020017, 0x10400002, 0x2021, 0x24040001, -0xc004da8, 0x108042, 0x1600fffa, 0x32020017, -0xc004da8, 0x24040001, 0xc004da8, 0x2021, -0x34108000, 0x96220000, 0x501024, 0x10400002, -0x2021, 0x24040001, 0xc004da8, 0x108042, -0x1600fff8, 0x0, 0xc004de9, 0x0, -0x8f830054, 0x1000011f, 0x2402000c, 0x8f830054, -0x3c020001, 0x8c426ffc, 0x2463ff9c, 0x431023, -0x2c420064, 0x14400127, 0x24020012, 0x10000123, -0x0, 0x27b10010, 0xa7a00010, 0x8021, -0xc004da8, 0x24040001, 0x26100001, 0x2e020020, -0x1440fffb, 0x0, 0xc004da8, 0x2021, -0xc004da8, 0x24040001, 0xc004da8, 0x24040001, -0xc004da8, 0x2021, 0x24100010, 0x32020001, -0x10400002, 0x2021, 0x24040001, 0xc004da8, -0x108042, 0x1600fffa, 0x32020001, 0x24100010, -0x32020014, 0x10400002, 0x2021, 0x24040001, -0xc004da8, 0x108042, 0x1600fffa, 0x32020014, -0xc004de9, 0x34108000, 0xc004de9, 0x0, -0xc004d88, 0x0, 0x50400005, 0x108042, -0x96220000, 0x501025, 0xa6220000, 0x108042, -0x1600fff7, 0x0, 0xc004de9, 0x8021, -0x97a20010, 0x27b10010, 0x34420010, 0xa7a20010, -0xc004da8, 0x24040001, 0x26100001, 0x2e020020, -0x1440fffb, 0x0, 0xc004da8, 0x2021, -0xc004da8, 0x24040001, 0xc004da8, 0x2021, -0xc004da8, 0x24040001, 0x24100010, 0x32020001, -0x10400002, 0x2021, 0x24040001, 0xc004da8, -0x108042, 0x1600fffa, 0x32020001, 0x24100010, -0x32020014, 0x10400002, 0x2021, 0x24040001, -0xc004da8, 0x108042, 0x1600fffa, 0x32020014, -0xc004da8, 0x24040001, 0xc004da8, 0x2021, -0x34108000, 0x96220000, 0x501024, 0x10400002, -0x2021, 0x24040001, 0xc004da8, 0x108042, -0x1600fff8, 0x0, 0xc004de9, 0x0, -0x8f830054, 0x100000ab, 0x24020013, 0x8f830054, -0x3c020001, 0x8c426ffc, 0x2463ff9c, 0x431023, -0x2c420064, 0x144000b3, 0x2402000d, 0x100000af, -0x0, 0x27b10010, 0xa7a00010, 0x8021, -0xc004da8, 0x24040001, 0x26100001, 0x2e020020, -0x1440fffb, 0x0, 0xc004da8, 0x2021, -0xc004da8, 0x24040001, 0xc004da8, 0x24040001, -0xc004da8, 0x2021, 0x24100010, 0x32020001, -0x10400002, 0x2021, 0x24040001, 0xc004da8, -0x108042, 0x1600fffa, 0x32020001, 0x24100010, -0x32020018, 0x10400002, 0x2021, 0x24040001, -0xc004da8, 0x108042, 0x1600fffa, 0x32020018, -0xc004de9, 0x34108000, 0xc004de9, 0x0, -0xc004d88, 0x0, 0x50400005, 0x108042, -0x96220000, 0x501025, 0xa6220000, 0x108042, -0x1600fff7, 0x0, 0xc004de9, 0x8021, -0x97a20010, 0x27b10010, 0x3042fffe, 0xa7a20010, -0xc004da8, 0x24040001, 0x26100001, 0x2e020020, -0x1440fffb, 0x0, 0xc004da8, 0x2021, -0xc004da8, 0x24040001, 0xc004da8, 0x2021, -0xc004da8, 0x24040001, 0x24100010, 0x32020001, -0x10400002, 0x2021, 0x24040001, 0xc004da8, -0x108042, 0x1600fffa, 0x32020001, 0x24100010, -0x32020018, 0x10400002, 0x2021, 0x24040001, -0xc004da8, 0x108042, 0x1600fffa, 0x32020018, -0xc004da8, 0x24040001, 0xc004da8, 0x2021, -0x34108000, 0x96220000, 0x501024, 0x10400002, -0x2021, 0x24040001, 0xc004da8, 0x108042, -0x1600fff8, 0x0, 0xc004de9, 0x0, -0x8f830054, 0x10000037, 0x2402000e, 0x24020840, -0xa7a20010, 0x27b10010, 0x8021, 0xc004da8, -0x24040001, 0x26100001, 0x2e020020, 0x1440fffb, -0x0, 0xc004da8, 0x2021, 0xc004da8, -0x24040001, 0xc004da8, 0x2021, 0xc004da8, -0x24040001, 0x24100010, 0x32020001, 0x10400002, -0x2021, 0x24040001, 0xc004da8, 0x108042, -0x1600fffa, 0x32020001, 0x24100010, 0x32020013, -0x10400002, 0x2021, 0x24040001, 0xc004da8, -0x108042, 0x1600fffa, 0x32020013, 0xc004da8, -0x24040001, 0xc004da8, 0x2021, 0x34108000, +0x10400002, 0x2021, 0x24040001, 0xc00538f, +0x108042, 0x1600fffa, 0x32020012, 0xc00538f, +0x24040001, 0xc00538f, 0x2021, 0x34108000, 0x96220000, 0x501024, 0x10400002, 0x2021, -0x24040001, 0xc004da8, 0x108042, 0x1600fff8, -0x0, 0xc004de9, 0x0, 0x8f830054, -0x24020010, 0x3c010001, 0xac226e90, 0x3c010001, -0x1000000c, 0xac236ffc, 0x8f830054, 0x3c020001, -0x8c426ffc, 0x2463ff9c, 0x431023, 0x2c420064, -0x14400004, 0x0, 0x24020011, 0x3c010001, -0xac226e90, 0x8fbf0020, 0x8fb1001c, 0x8fb00018, -0x3e00008, 0x27bd0028, 0x3c030001, 0x8c636e58, -0x27bdffc8, 0x24020002, 0xafbf0034, 0xafb20030, -0xafb1002c, 0x14620004, 0xafb00028, 0x3c120002, -0x10000003, 0x8e5290b8, 0x3c120002, 0x8e5290bc, -0x3c030001, 0x8c636e94, 0x3c020001, 0x8c426edc, -0x50620004, 0x2463ffff, 0x3c010001, 0xac236edc, -0x2463ffff, 0x2c620006, 0x10400377, 0x31080, -0x3c010001, 0x220821, 0x8c226c98, 0x400008, -0x0, 0x2021, 0x2821, 0xc004e0b, -0x34068000, 0x24040010, 0x24050002, 0x24060002, -0x24020002, 0xc004e0b, 0xa7a20018, 0x24020002, -0x3c010001, 0x10000364, 0xac226e94, 0x27b10018, -0xa7a00018, 0x8021, 0xc004da8, 0x24040001, +0x24040001, 0xc00538f, 0x108042, 0x1600fff8, +0x0, 0xc0053aa, 0x0, 0x8f830054, +0x1000024e, 0x24020006, 0x8f830054, 0x3c020002, +0x8c42865c, 0x2463ff9c, 0x431023, 0x2c420064, +0x14400257, 0x24030007, 0x3c020002, 0x8c428660, +0x10430251, 0x24020011, 0x3c010002, 0xac2384fc, +0x1000024f, 0x0, 0x24020006, 0xa7a20010, +0x27b10010, 0x8021, 0xc00538f, 0x24040001, +0x26100001, 0x2e020020, 0x1440fffb, 0x0, +0xc00538f, 0x2021, 0xc00538f, 0x24040001, +0xc00538f, 0x2021, 0xc00538f, 0x24040001, +0x24100010, 0x32020001, 0x10400002, 0x2021, +0x24040001, 0xc00538f, 0x108042, 0x1600fffa, +0x32020001, 0x24100010, 0x32020013, 0x10400002, +0x2021, 0x24040001, 0xc00538f, 0x108042, +0x1600fffa, 0x32020013, 0xc00538f, 0x24040001, +0xc00538f, 0x2021, 0x34108000, 0x96220000, +0x501024, 0x10400002, 0x2021, 0x24040001, +0xc00538f, 0x108042, 0x1600fff8, 0x0, +0xc0053aa, 0x0, 0x8f830054, 0x10000207, +0x24020008, 0x8f830054, 0x3c020002, 0x8c42865c, +0x2463ff9c, 0x431023, 0x2c420064, 0x14400210, +0x24020009, 0x1000020c, 0x0, 0x27b10010, +0xa7a00010, 0x8021, 0xc00538f, 0x24040001, +0x26100001, 0x2e020020, 0x1440fffb, 0x0, +0xc00538f, 0x2021, 0xc00538f, 0x24040001, +0xc00538f, 0x24040001, 0xc00538f, 0x2021, +0x24100010, 0x32020001, 0x10400002, 0x2021, +0x24040001, 0xc00538f, 0x108042, 0x1600fffa, +0x32020001, 0x24100010, 0x32020018, 0x10400002, +0x2021, 0x24040001, 0xc00538f, 0x108042, +0x1600fffa, 0x32020018, 0xc0053aa, 0x34108000, +0xc0053aa, 0x0, 0xc005382, 0x0, +0x50400005, 0x108042, 0x96220000, 0x501025, +0xa6220000, 0x108042, 0x1600fff7, 0x0, +0xc0053aa, 0x8021, 0x97a20010, 0x27b10010, +0x34420001, 0xa7a20010, 0xc00538f, 0x24040001, +0x26100001, 0x2e020020, 0x1440fffb, 0x0, +0xc00538f, 0x2021, 0xc00538f, 0x24040001, +0xc00538f, 0x2021, 0xc00538f, 0x24040001, +0x24100010, 0x32020001, 0x10400002, 0x2021, +0x24040001, 0xc00538f, 0x108042, 0x1600fffa, +0x32020001, 0x24100010, 0x32020018, 0x10400002, +0x2021, 0x24040001, 0xc00538f, 0x108042, +0x1600fffa, 0x32020018, 0xc00538f, 0x24040001, +0xc00538f, 0x2021, 0x34108000, 0x96220000, +0x501024, 0x10400002, 0x2021, 0x24040001, +0xc00538f, 0x108042, 0x1600fff8, 0x0, +0xc0053aa, 0x0, 0x8f830054, 0x10000193, +0x2402000a, 0x8f830054, 0x3c020002, 0x8c42865c, +0x2463ff9c, 0x431023, 0x2c420064, 0x1440019c, +0x2402000b, 0x10000198, 0x0, 0x27b10010, +0xa7a00010, 0x8021, 0xc00538f, 0x24040001, +0x26100001, 0x2e020020, 0x1440fffb, 0x0, +0xc00538f, 0x2021, 0xc00538f, 0x24040001, +0xc00538f, 0x24040001, 0xc00538f, 0x2021, +0x24100010, 0x32020001, 0x10400002, 0x2021, +0x24040001, 0xc00538f, 0x108042, 0x1600fffa, +0x32020001, 0x24100010, 0x32020017, 0x10400002, +0x2021, 0x24040001, 0xc00538f, 0x108042, +0x1600fffa, 0x32020017, 0xc0053aa, 0x34108000, +0xc0053aa, 0x0, 0xc005382, 0x0, +0x50400005, 0x108042, 0x96220000, 0x501025, +0xa6220000, 0x108042, 0x1600fff7, 0x0, +0xc0053aa, 0x8021, 0x97a20010, 0x27b10010, +0x34420700, 0xa7a20010, 0xc00538f, 0x24040001, +0x26100001, 0x2e020020, 0x1440fffb, 0x0, +0xc00538f, 0x2021, 0xc00538f, 0x24040001, +0xc00538f, 0x2021, 0xc00538f, 0x24040001, +0x24100010, 0x32020001, 0x10400002, 0x2021, +0x24040001, 0xc00538f, 0x108042, 0x1600fffa, +0x32020001, 0x24100010, 0x32020017, 0x10400002, +0x2021, 0x24040001, 0xc00538f, 0x108042, +0x1600fffa, 0x32020017, 0xc00538f, 0x24040001, +0xc00538f, 0x2021, 0x34108000, 0x96220000, +0x501024, 0x10400002, 0x2021, 0x24040001, +0xc00538f, 0x108042, 0x1600fff8, 0x0, +0xc0053aa, 0x0, 0x8f830054, 0x1000011f, +0x2402000c, 0x8f830054, 0x3c020002, 0x8c42865c, +0x2463ff9c, 0x431023, 0x2c420064, 0x14400128, +0x24020012, 0x10000124, 0x0, 0x27b10010, +0xa7a00010, 0x8021, 0xc00538f, 0x24040001, +0x26100001, 0x2e020020, 0x1440fffb, 0x0, +0xc00538f, 0x2021, 0xc00538f, 0x24040001, +0xc00538f, 0x24040001, 0xc00538f, 0x2021, +0x24100010, 0x32020001, 0x10400002, 0x2021, +0x24040001, 0xc00538f, 0x108042, 0x1600fffa, +0x32020001, 0x24100010, 0x32020014, 0x10400002, +0x2021, 0x24040001, 0xc00538f, 0x108042, +0x1600fffa, 0x32020014, 0xc0053aa, 0x34108000, +0xc0053aa, 0x0, 0xc005382, 0x0, +0x50400005, 0x108042, 0x96220000, 0x501025, +0xa6220000, 0x108042, 0x1600fff7, 0x0, +0xc0053aa, 0x8021, 0x97a20010, 0x27b10010, +0x34420010, 0xa7a20010, 0xc00538f, 0x24040001, +0x26100001, 0x2e020020, 0x1440fffb, 0x0, +0xc00538f, 0x2021, 0xc00538f, 0x24040001, +0xc00538f, 0x2021, 0xc00538f, 0x24040001, +0x24100010, 0x32020001, 0x10400002, 0x2021, +0x24040001, 0xc00538f, 0x108042, 0x1600fffa, +0x32020001, 0x24100010, 0x32020014, 0x10400002, +0x2021, 0x24040001, 0xc00538f, 0x108042, +0x1600fffa, 0x32020014, 0xc00538f, 0x24040001, +0xc00538f, 0x2021, 0x34108000, 0x96220000, +0x501024, 0x10400002, 0x2021, 0x24040001, +0xc00538f, 0x108042, 0x1600fff8, 0x0, +0xc0053aa, 0x0, 0x8f830054, 0x100000ab, +0x24020013, 0x8f830054, 0x3c020002, 0x8c42865c, +0x2463ff9c, 0x431023, 0x2c420064, 0x144000b4, +0x2402000d, 0x100000b0, 0x0, 0x27b10010, +0xa7a00010, 0x8021, 0xc00538f, 0x24040001, +0x26100001, 0x2e020020, 0x1440fffb, 0x0, +0xc00538f, 0x2021, 0xc00538f, 0x24040001, +0xc00538f, 0x24040001, 0xc00538f, 0x2021, +0x24100010, 0x32020001, 0x10400002, 0x2021, +0x24040001, 0xc00538f, 0x108042, 0x1600fffa, +0x32020001, 0x24100010, 0x32020018, 0x10400002, +0x2021, 0x24040001, 0xc00538f, 0x108042, +0x1600fffa, 0x32020018, 0xc0053aa, 0x34108000, +0xc0053aa, 0x0, 0xc005382, 0x0, +0x50400005, 0x108042, 0x96220000, 0x501025, +0xa6220000, 0x108042, 0x1600fff7, 0x0, +0xc0053aa, 0x8021, 0x97a20010, 0x27b10010, +0x3042fffe, 0xa7a20010, 0xc00538f, 0x24040001, 0x26100001, 0x2e020020, 0x1440fffb, 0x0, -0xc004da8, 0x2021, 0xc004da8, 0x24040001, -0xc004da8, 0x24040001, 0xc004da8, 0x2021, +0xc00538f, 0x2021, 0xc00538f, 0x24040001, +0xc00538f, 0x2021, 0xc00538f, 0x24040001, 0x24100010, 0x32020001, 0x10400002, 0x2021, -0x24040001, 0xc004da8, 0x108042, 0x1600fffa, -0x32020001, 0x24100010, 0xc004da8, 0x2021, -0x108042, 0x1600fffc, 0x0, 0xc004de9, -0x34108000, 0xc004de9, 0x0, 0xc004d88, -0x0, 0x50400005, 0x108042, 0x96220000, -0x501025, 0xa6220000, 0x108042, 0x1600fff7, -0x0, 0xc004de9, 0x0, 0x97a20018, -0x30428000, 0x14400004, 0x24020003, 0x3c010001, -0xac226e94, 0x24020003, 0x3c010001, 0x1000032a, -0xac226e94, 0x24040010, 0x24050002, 0x24060002, -0x24020002, 0xc004e0b, 0xa7a20018, 0x3c030001, -0x8c636ee0, 0x24020001, 0x146201e1, 0x8021, -0x27b10018, 0xa7a00018, 0xc004da8, 0x24040001, +0x24040001, 0xc00538f, 0x108042, 0x1600fffa, +0x32020001, 0x24100010, 0x32020018, 0x10400002, +0x2021, 0x24040001, 0xc00538f, 0x108042, +0x1600fffa, 0x32020018, 0xc00538f, 0x24040001, +0xc00538f, 0x2021, 0x34108000, 0x96220000, +0x501024, 0x10400002, 0x2021, 0x24040001, +0xc00538f, 0x108042, 0x1600fff8, 0x0, +0xc0053aa, 0x0, 0x8f830054, 0x10000037, +0x2402000e, 0x24020840, 0xa7a20010, 0x27b10010, +0x8021, 0xc00538f, 0x24040001, 0x26100001, +0x2e020020, 0x1440fffb, 0x0, 0xc00538f, +0x2021, 0xc00538f, 0x24040001, 0xc00538f, +0x2021, 0xc00538f, 0x24040001, 0x24100010, +0x32020001, 0x10400002, 0x2021, 0x24040001, +0xc00538f, 0x108042, 0x1600fffa, 0x32020001, +0x24100010, 0x32020013, 0x10400002, 0x2021, +0x24040001, 0xc00538f, 0x108042, 0x1600fffa, +0x32020013, 0xc00538f, 0x24040001, 0xc00538f, +0x2021, 0x34108000, 0x96220000, 0x501024, +0x10400002, 0x2021, 0x24040001, 0xc00538f, +0x108042, 0x1600fff8, 0x0, 0xc0053aa, +0x0, 0x8f830054, 0x24020010, 0x3c010002, +0xac2284fc, 0x3c010002, 0xac23865c, 0x1000000c, +0x0, 0x8f830054, 0x3c020002, 0x8c42865c, +0x2463ff9c, 0x431023, 0x2c420064, 0x14400004, +0x0, 0x24020011, 0x3c010002, 0xac2284fc, +0x8fbf0020, 0x8fb1001c, 0x8fb00018, 0x3e00008, +0x27bd0028, 0x3c030002, 0x8c6384cc, 0x27bdffc8, +0x24020002, 0xafbf0034, 0xafb20030, 0xafb1002c, +0x14620005, 0xafb00028, 0x3c120002, 0x8e52a718, +0x10000003, 0x0, 0x3c120002, 0x8e52a71c, +0x3c060002, 0x8cc68500, 0x3c020002, 0x8c428548, +0x10c2000f, 0x3c05000d, 0x3c040002, 0x2484814c, +0x3c070002, 0x8ce78550, 0x3c020002, 0x8c4284cc, +0x34a50201, 0xafb20010, 0xc002d3b, 0xafa20014, +0x3c020002, 0x8c428500, 0x3c010002, 0xac228548, +0x3c020002, 0x8c428500, 0x2443ffff, 0x2c620006, +0x1040030d, 0x31080, 0x3c010002, 0x220821, +0x8c228158, 0x400008, 0x0, 0x2021, +0x2821, 0xc0053b9, 0x34068000, 0x24040010, +0x24050002, 0x24060002, 0x24020002, 0xc0053b9, +0xa7a20018, 0x24020002, 0x3c010002, 0xac228500, +0x100002f9, 0x0, 0x27b10018, 0xa7a00018, +0x8021, 0xc00538f, 0x24040001, 0x26100001, +0x2e020020, 0x1440fffb, 0x0, 0xc00538f, +0x2021, 0xc00538f, 0x24040001, 0xc00538f, +0x24040001, 0xc00538f, 0x2021, 0x24100010, +0x32020001, 0x10400002, 0x2021, 0x24040001, +0xc00538f, 0x108042, 0x1600fffa, 0x32020001, +0x24100010, 0xc00538f, 0x2021, 0x108042, +0x1600fffc, 0x0, 0xc0053aa, 0x34108000, +0xc0053aa, 0x0, 0xc005382, 0x0, +0x50400005, 0x108042, 0x96220000, 0x501025, +0xa6220000, 0x108042, 0x1600fff7, 0x0, +0xc0053aa, 0x0, 0x97a20018, 0x30428000, +0x14400004, 0x24020003, 0x3c010002, 0xac228500, +0x24020003, 0x3c010002, 0xac228500, 0x100002be, +0x0, 0x24040010, 0x24050002, 0x24060002, +0x24020002, 0xc0053b9, 0xa7a20018, 0x3c030002, +0x8c63854c, 0x24020001, 0x146201e1, 0x8021, +0x27b10018, 0xa7a00018, 0xc00538f, 0x24040001, 0x26100001, 0x2e020020, 0x1440fffb, 0x0, -0xc004da8, 0x2021, 0xc004da8, 0x24040001, -0xc004da8, 0x24040001, 0xc004da8, 0x2021, +0xc00538f, 0x2021, 0xc00538f, 0x24040001, +0xc00538f, 0x24040001, 0xc00538f, 0x2021, 0x24100010, 0x32020001, 0x10400002, 0x2021, -0x24040001, 0xc004da8, 0x108042, 0x1600fffa, +0x24040001, 0xc00538f, 0x108042, 0x1600fffa, 0x32020001, 0x24100010, 0x32020018, 0x10400002, -0x2021, 0x24040001, 0xc004da8, 0x108042, -0x1600fffa, 0x32020018, 0xc004de9, 0x34108000, -0xc004de9, 0x0, 0xc004d88, 0x0, +0x2021, 0x24040001, 0xc00538f, 0x108042, +0x1600fffa, 0x32020018, 0xc0053aa, 0x34108000, +0xc0053aa, 0x0, 0xc005382, 0x0, 0x50400005, 0x108042, 0x96220000, 0x501025, 0xa6220000, 0x108042, 0x1600fff7, 0x0, -0xc004de9, 0x8021, 0x27b10018, 0xa7a00018, -0xc004da8, 0x24040001, 0x26100001, 0x2e020020, -0x1440fffb, 0x0, 0xc004da8, 0x2021, -0xc004da8, 0x24040001, 0xc004da8, 0x24040001, -0xc004da8, 0x2021, 0x24100010, 0x32020001, -0x10400002, 0x2021, 0x24040001, 0xc004da8, +0xc0053aa, 0x8021, 0x27b10018, 0xa7a00018, +0xc00538f, 0x24040001, 0x26100001, 0x2e020020, +0x1440fffb, 0x0, 0xc00538f, 0x2021, +0xc00538f, 0x24040001, 0xc00538f, 0x24040001, +0xc00538f, 0x2021, 0x24100010, 0x32020001, +0x10400002, 0x2021, 0x24040001, 0xc00538f, 0x108042, 0x1600fffa, 0x32020001, 0x24100010, 0x32020018, 0x10400002, 0x2021, 0x24040001, -0xc004da8, 0x108042, 0x1600fffa, 0x32020018, -0xc004de9, 0x34108000, 0xc004de9, 0x0, -0xc004d88, 0x0, 0x50400005, 0x108042, +0xc00538f, 0x108042, 0x1600fffa, 0x32020018, +0xc0053aa, 0x34108000, 0xc0053aa, 0x0, +0xc005382, 0x0, 0x50400005, 0x108042, 0x96220000, 0x501025, 0xa6220000, 0x108042, -0x1600fff7, 0x0, 0xc004de9, 0x8021, -0x24040018, 0x2821, 0xc004e0b, 0x24060404, -0xa7a0001a, 0xc004da8, 0x24040001, 0x26100001, -0x2e020020, 0x1440fffb, 0x0, 0xc004da8, -0x2021, 0xc004da8, 0x24040001, 0xc004da8, -0x24040001, 0xc004da8, 0x2021, 0x24100010, +0x1600fff7, 0x0, 0xc0053aa, 0x8021, +0x24040018, 0x2821, 0xc0053b9, 0x24060404, +0xa7a0001a, 0xc00538f, 0x24040001, 0x26100001, +0x2e020020, 0x1440fffb, 0x0, 0xc00538f, +0x2021, 0xc00538f, 0x24040001, 0xc00538f, +0x24040001, 0xc00538f, 0x2021, 0x24100010, 0x32020001, 0x10400002, 0x2021, 0x24040001, -0xc004da8, 0x108042, 0x1600fffa, 0x32020001, +0xc00538f, 0x108042, 0x1600fffa, 0x32020001, 0x24100010, 0x32020018, 0x10400002, 0x2021, -0x24040001, 0xc004da8, 0x108042, 0x1600fffa, -0x32020018, 0xc004de9, 0x34108000, 0xc004de9, -0x0, 0xc004d88, 0x0, 0x50400005, +0x24040001, 0xc00538f, 0x108042, 0x1600fffa, +0x32020018, 0xc0053aa, 0x34108000, 0xc0053aa, +0x0, 0xc005382, 0x0, 0x50400005, 0x108042, 0x97a2001a, 0x501025, 0xa7a2001a, -0x108042, 0x1600fff7, 0x0, 0xc004de9, -0x8021, 0xa7a0001a, 0xc004da8, 0x24040001, +0x108042, 0x1600fff7, 0x0, 0xc0053aa, +0x8021, 0xa7a0001a, 0xc00538f, 0x24040001, 0x26100001, 0x2e020020, 0x1440fffb, 0x0, -0xc004da8, 0x2021, 0xc004da8, 0x24040001, -0xc004da8, 0x24040001, 0xc004da8, 0x2021, +0xc00538f, 0x2021, 0xc00538f, 0x24040001, +0xc00538f, 0x24040001, 0xc00538f, 0x2021, 0x24100010, 0x32020001, 0x10400002, 0x2021, -0x24040001, 0xc004da8, 0x108042, 0x1600fffa, +0x24040001, 0xc00538f, 0x108042, 0x1600fffa, 0x32020001, 0x24100010, 0x32020018, 0x10400002, -0x2021, 0x24040001, 0xc004da8, 0x108042, -0x1600fffa, 0x32020018, 0xc004de9, 0x34108000, -0xc004de9, 0x0, 0xc004d88, 0x0, +0x2021, 0x24040001, 0xc00538f, 0x108042, +0x1600fffa, 0x32020018, 0xc0053aa, 0x34108000, +0xc0053aa, 0x0, 0xc005382, 0x0, 0x50400005, 0x108042, 0x97a2001a, 0x501025, 0xa7a2001a, 0x108042, 0x1600fff7, 0x0, -0xc004de9, 0x8021, 0xa7a0001c, 0xc004da8, +0xc0053aa, 0x8021, 0xa7a0001c, 0xc00538f, 0x24040001, 0x26100001, 0x2e020020, 0x1440fffb, -0x0, 0xc004da8, 0x2021, 0xc004da8, -0x24040001, 0xc004da8, 0x24040001, 0xc004da8, -0x2021, 0x24100010, 0xc004da8, 0x2021, +0x0, 0xc00538f, 0x2021, 0xc00538f, +0x24040001, 0xc00538f, 0x24040001, 0xc00538f, +0x2021, 0x24100010, 0xc00538f, 0x2021, 0x108042, 0x1600fffc, 0x0, 0x24100010, 0x3202001e, 0x10400002, 0x2021, 0x24040001, -0xc004da8, 0x108042, 0x1600fffa, 0x3202001e, -0xc004de9, 0x34108000, 0xc004de9, 0x0, -0xc004d88, 0x0, 0x50400005, 0x108042, +0xc00538f, 0x108042, 0x1600fffa, 0x3202001e, +0xc0053aa, 0x34108000, 0xc0053aa, 0x0, +0xc005382, 0x0, 0x50400005, 0x108042, 0x97a2001c, 0x501025, 0xa7a2001c, 0x108042, -0x1600fff7, 0x0, 0xc004de9, 0x8021, -0xa7a0001c, 0xc004da8, 0x24040001, 0x26100001, -0x2e020020, 0x1440fffb, 0x0, 0xc004da8, -0x2021, 0xc004da8, 0x24040001, 0xc004da8, -0x24040001, 0xc004da8, 0x2021, 0x24100010, -0xc004da8, 0x2021, 0x108042, 0x1600fffc, +0x1600fff7, 0x0, 0xc0053aa, 0x8021, +0xa7a0001c, 0xc00538f, 0x24040001, 0x26100001, +0x2e020020, 0x1440fffb, 0x0, 0xc00538f, +0x2021, 0xc00538f, 0x24040001, 0xc00538f, +0x24040001, 0xc00538f, 0x2021, 0x24100010, +0xc00538f, 0x2021, 0x108042, 0x1600fffc, 0x0, 0x24100010, 0x3202001e, 0x10400002, -0x2021, 0x24040001, 0xc004da8, 0x108042, -0x1600fffa, 0x3202001e, 0xc004de9, 0x34108000, -0xc004de9, 0x0, 0xc004d88, 0x0, +0x2021, 0x24040001, 0xc00538f, 0x108042, +0x1600fffa, 0x3202001e, 0xc0053aa, 0x34108000, +0xc0053aa, 0x0, 0xc005382, 0x0, 0x50400005, 0x108042, 0x97a2001c, 0x501025, 0xa7a2001c, 0x108042, 0x1600fff7, 0x0, -0xc004de9, 0x8021, 0x24020002, 0xa7a2001e, -0xc004da8, 0x24040001, 0x26100001, 0x2e020020, -0x1440fffb, 0x0, 0xc004da8, 0x2021, -0xc004da8, 0x24040001, 0xc004da8, 0x2021, -0xc004da8, 0x24040001, 0x24100010, 0xc004da8, +0xc0053aa, 0x8021, 0x24020002, 0xa7a2001e, +0xc00538f, 0x24040001, 0x26100001, 0x2e020020, +0x1440fffb, 0x0, 0xc00538f, 0x2021, +0xc00538f, 0x24040001, 0xc00538f, 0x2021, +0xc00538f, 0x24040001, 0x24100010, 0xc00538f, 0x2021, 0x108042, 0x1600fffc, 0x0, 0x24100010, 0x3202001e, 0x10400002, 0x2021, -0x24040001, 0xc004da8, 0x108042, 0x1600fffa, -0x3202001e, 0xc004da8, 0x24040001, 0xc004da8, +0x24040001, 0xc00538f, 0x108042, 0x1600fffa, +0x3202001e, 0xc00538f, 0x24040001, 0xc00538f, 0x2021, 0x34108000, 0x97a2001e, 0x501024, -0x10400002, 0x2021, 0x24040001, 0xc004da8, -0x108042, 0x1600fff8, 0x0, 0xc004de9, -0x8021, 0xa7a00020, 0xc004da8, 0x24040001, +0x10400002, 0x2021, 0x24040001, 0xc00538f, +0x108042, 0x1600fff8, 0x0, 0xc0053aa, +0x8021, 0xa7a00020, 0xc00538f, 0x24040001, 0x26100001, 0x2e020020, 0x1440fffb, 0x0, -0xc004da8, 0x2021, 0xc004da8, 0x24040001, -0xc004da8, 0x24040001, 0xc004da8, 0x2021, -0x24100010, 0xc004da8, 0x2021, 0x108042, +0xc00538f, 0x2021, 0xc00538f, 0x24040001, +0xc00538f, 0x24040001, 0xc00538f, 0x2021, +0x24100010, 0xc00538f, 0x2021, 0x108042, 0x1600fffc, 0x0, 0x24100010, 0x3202001e, -0x10400002, 0x2021, 0x24040001, 0xc004da8, -0x108042, 0x1600fffa, 0x3202001e, 0xc004de9, -0x34108000, 0xc004de9, 0x0, 0xc004d88, +0x10400002, 0x2021, 0x24040001, 0xc00538f, +0x108042, 0x1600fffa, 0x3202001e, 0xc0053aa, +0x34108000, 0xc0053aa, 0x0, 0xc005382, 0x0, 0x50400005, 0x108042, 0x97a20020, 0x501025, 0xa7a20020, 0x108042, 0x1600fff7, -0x0, 0xc004de9, 0x8021, 0xa7a00020, -0xc004da8, 0x24040001, 0x26100001, 0x2e020020, -0x1440fffb, 0x0, 0xc004da8, 0x2021, -0xc004da8, 0x24040001, 0xc004da8, 0x24040001, -0xc004da8, 0x2021, 0x24100010, 0xc004da8, +0x0, 0xc0053aa, 0x8021, 0xa7a00020, +0xc00538f, 0x24040001, 0x26100001, 0x2e020020, +0x1440fffb, 0x0, 0xc00538f, 0x2021, +0xc00538f, 0x24040001, 0xc00538f, 0x24040001, +0xc00538f, 0x2021, 0x24100010, 0xc00538f, 0x2021, 0x108042, 0x1600fffc, 0x0, 0x24100010, 0x3202001e, 0x10400002, 0x2021, -0x24040001, 0xc004da8, 0x108042, 0x1600fffa, -0x3202001e, 0xc004de9, 0x34108000, 0xc004de9, -0x0, 0xc004d88, 0x0, 0x50400005, +0x24040001, 0xc00538f, 0x108042, 0x1600fffa, +0x3202001e, 0xc0053aa, 0x34108000, 0xc0053aa, +0x0, 0xc005382, 0x0, 0x50400005, 0x108042, 0x97a20020, 0x501025, 0xa7a20020, -0x108042, 0x1600fff7, 0x0, 0xc004de9, -0x8021, 0xa7a00022, 0xc004da8, 0x24040001, +0x108042, 0x1600fff7, 0x0, 0xc0053aa, +0x8021, 0xa7a00022, 0xc00538f, 0x24040001, 0x26100001, 0x2e020020, 0x1440fffb, 0x0, -0xc004da8, 0x2021, 0xc004da8, 0x24040001, -0xc004da8, 0x2021, 0xc004da8, 0x24040001, -0x24100010, 0xc004da8, 0x2021, 0x108042, -0x1600fffc, 0x0, 0x24100010, 0xc004da8, +0xc00538f, 0x2021, 0xc00538f, 0x24040001, +0xc00538f, 0x2021, 0xc00538f, 0x24040001, +0x24100010, 0xc00538f, 0x2021, 0x108042, +0x1600fffc, 0x0, 0x24100010, 0xc00538f, 0x2021, 0x108042, 0x1600fffc, 0x0, -0xc004da8, 0x24040001, 0xc004da8, 0x2021, +0xc00538f, 0x24040001, 0xc00538f, 0x2021, 0x34108000, 0x97a20022, 0x501024, 0x10400002, -0x2021, 0x24040001, 0xc004da8, 0x108042, -0x1600fff8, 0x0, 0xc004de9, 0x0, -0x24040018, 0x24050002, 0xc004e0b, 0x24060004, -0x3c100001, 0x8e106ee4, 0x24020001, 0x1602011d, -0x0, 0x3c020001, 0x94426fe6, 0x3c010001, -0xac206ee4, 0x24429fbc, 0x2c420004, 0x1040000c, -0x24040009, 0x24050001, 0xc004e0b, 0x24060400, -0x24040018, 0x24050001, 0xc004e0b, 0x24060020, -0x24040018, 0x24050001, 0xc004e0b, 0x24062000, -0x3c024000, 0x2421024, 0x10400123, 0x3c022000, -0x2421024, 0x10400004, 0x0, 0x3c010001, -0x10000003, 0xac306fdc, 0x3c010001, 0xac206fdc, -0x3c030001, 0x8c636ff4, 0x24020005, 0x146200f9, -0x0, 0x3c020001, 0x8c426fdc, 0x10400067, -0x3c020004, 0x2421024, 0x10400011, 0xa7a00018, -0x3c020008, 0x2421024, 0x10400002, 0x24020200, -0xa7a20018, 0x3c020010, 0x2421024, 0x10400004, -0x0, 0x97a20018, 0x34420100, 0xa7a20018, -0x97a60018, 0x24040009, 0x10000004, 0x2821, -0x24040009, 0x2821, 0x3021, 0xc004e0b, -0x0, 0x24020001, 0xa7a2001a, 0x3c020008, -0x2421024, 0x1040000c, 0x3c020002, 0x2421024, -0x10400002, 0x24020101, 0xa7a2001a, 0x3c020001, -0x2421024, 0x10400005, 0x3c020010, 0x97a2001a, -0x34420040, 0xa7a2001a, 0x3c020010, 0x2421024, -0x1040000e, 0x3c020002, 0x2421024, 0x10400005, -0x3c020001, 0x97a2001a, 0x34420080, 0xa7a2001a, -0x3c020001, 0x2421024, 0x10400005, 0x3c0300a0, -0x97a2001a, 0x34420020, 0xa7a2001a, 0x3c0300a0, -0x2431024, 0x54430004, 0x3c020020, 0x97a2001a, -0x1000000c, 0x34420400, 0x2421024, 0x50400004, -0x3c020080, 0x97a2001a, 0x10000006, 0x34420800, -0x2421024, 0x10400004, 0x0, 0x97a2001a, -0x34420c00, 0xa7a2001a, 0x97a6001a, 0x24040004, -0xc004e0b, 0x2821, 0x3c020004, 0x2421024, -0x10400004, 0xa7a0001c, 0x32425000, 0x14400004, -0x0, 0x32424000, 0x10400005, 0x2021, -0xc004d29, 0x2402021, 0x10000096, 0x0, -0x97a6001c, 0x2821, 0x34c61200, 0xc004e0b, -0xa7a6001c, 0x1000008f, 0x0, 0x2421024, -0x10400004, 0xa7a00018, 0x32425000, 0x14400004, -0x0, 0x32424000, 0x10400005, 0x3c020010, -0xc004d29, 0x2402021, 0x10000019, 0xa7a0001a, -0x2421024, 0x10400004, 0x0, 0x97a20018, -0x10000004, 0xa7a20018, 0x97a20018, 0x34420100, -0xa7a20018, 0x3c020001, 0x2421024, 0x10400004, -0x0, 0x97a20018, 0x10000004, 0xa7a20018, -0x97a20018, 0x34422000, 0xa7a20018, 0x97a60018, -0x2021, 0xc004e0b, 0x2821, 0xa7a0001a, -0x8021, 0xc004da8, 0x24040001, 0x26100001, -0x2e020020, 0x1440fffb, 0x0, 0xc004da8, -0x2021, 0xc004da8, 0x24040001, 0xc004da8, -0x24040001, 0xc004da8, 0x2021, 0x24100010, -0x32020001, 0x10400002, 0x2021, 0x24040001, -0xc004da8, 0x108042, 0x1600fffa, 0x32020001, -0x24100010, 0xc004da8, 0x2021, 0x108042, -0x1600fffc, 0x0, 0xc004de9, 0x34108000, -0xc004de9, 0x0, 0xc004d88, 0x0, -0x50400005, 0x108042, 0x97a2001a, 0x501025, -0xa7a2001a, 0x108042, 0x1600fff7, 0x0, -0xc004de9, 0x8021, 0xa7a0001a, 0xc004da8, -0x24040001, 0x26100001, 0x2e020020, 0x1440fffb, -0x0, 0xc004da8, 0x2021, 0xc004da8, -0x24040001, 0xc004da8, 0x24040001, 0xc004da8, -0x2021, 0x24100010, 0x32020001, 0x10400002, -0x2021, 0x24040001, 0xc004da8, 0x108042, -0x1600fffa, 0x32020001, 0x24100010, 0xc004da8, -0x2021, 0x108042, 0x1600fffc, 0x0, -0xc004de9, 0x34108000, 0xc004de9, 0x0, -0xc004d88, 0x0, 0x50400005, 0x108042, -0x97a2001a, 0x501025, 0xa7a2001a, 0x108042, -0x1600fff7, 0x0, 0xc004de9, 0x0, -0x3c040001, 0x24846c8c, 0x97a60018, 0x97a7001a, -0x3c020001, 0x8c426e58, 0x3c030001, 0x8c636fdc, -0x3c05000d, 0x34a50205, 0xafa20010, 0xc002b37, -0xafa30014, 0x8f830054, 0x24020004, 0x3c010001, -0xac226e94, 0x3c010001, 0x10000017, 0xac236ff8, -0x8f830054, 0x3c020001, 0x8c426ff8, 0x2463ff9c, -0x431023, 0x2c420064, 0x1440000f, 0x0, -0x8f820220, 0x24030005, 0x3c010001, 0xac236e94, -0x3c03f700, 0x431025, 0x10000007, 0xaf820220, -0x24020006, 0x3c010001, 0xac226e94, 0x24020011, -0x3c010001, 0xac226e90, 0x8fbf0034, 0x8fb20030, +0x2021, 0x24040001, 0xc00538f, 0x108042, +0x1600fff8, 0x0, 0xc0053aa, 0x0, +0x24040018, 0x24050002, 0xc0053b9, 0x24060004, +0x3c100002, 0x8e108550, 0x24020001, 0x160200af, +0x0, 0x3c020002, 0x94428646, 0x3c010002, +0xac208550, 0x24429fbc, 0x2c420004, 0x10400008, +0x24040009, 0x24050001, 0xc0053b9, 0x24060400, +0x24040018, 0x24050001, 0xc0053b9, 0x24060020, +0x24040018, 0x24050001, 0xc0053b9, 0x24062000, +0x3c024000, 0x2421024, 0x104000b7, 0x3c022000, +0x2421024, 0x10400005, 0x0, 0x3c010002, +0xac30863c, 0x10000003, 0x0, 0x3c010002, +0xac20863c, 0x3c030002, 0x8c638654, 0x24020005, +0x1462008a, 0x0, 0x3c020002, 0x8c42863c, +0x10400061, 0x3c020004, 0x2421024, 0x10400011, +0xa7a00018, 0x3c020008, 0x2421024, 0x10400002, +0x24020200, 0xa7a20018, 0x3c020010, 0x2421024, +0x10400004, 0x0, 0x97a20018, 0x34420100, +0xa7a20018, 0x97a60018, 0x24040009, 0x10000004, +0x2821, 0x24040009, 0x2821, 0x3021, +0xc0053b9, 0x0, 0x24020001, 0xa7a2001a, +0x3c020008, 0x2421024, 0x1040000c, 0x3c020002, +0x2421024, 0x10400002, 0x24020101, 0xa7a2001a, +0x3c020001, 0x2421024, 0x10400005, 0x3c020010, +0x97a2001a, 0x34420040, 0xa7a2001a, 0x3c020010, +0x2421024, 0x1040000e, 0x3c020002, 0x2421024, +0x10400005, 0x3c020001, 0x97a2001a, 0x34420080, +0xa7a2001a, 0x3c020001, 0x2421024, 0x10400005, +0x3c0300a0, 0x97a2001a, 0x34420020, 0xa7a2001a, +0x3c0300a0, 0x2431024, 0x54430004, 0x3c020020, +0x97a2001a, 0x1000000c, 0x34420400, 0x2421024, +0x50400004, 0x3c020080, 0x97a2001a, 0x10000006, +0x34420800, 0x2421024, 0x10400004, 0x0, +0x97a2001a, 0x34420c00, 0xa7a2001a, 0x97a6001a, +0x24040004, 0xc0053b9, 0x2821, 0x3c020004, +0x2421024, 0x10400004, 0xa7a0001c, 0x32425000, +0x14400012, 0x0, 0x32424000, 0x1440000f, +0x2021, 0x97a6001c, 0x2821, 0x34c61200, +0x10000024, 0xa7a6001c, 0x2421024, 0x10400004, +0xa7a00018, 0x32425000, 0x14400004, 0x0, +0x32424000, 0x10400005, 0x3c020010, 0xc005321, +0x2402021, 0x10000019, 0x0, 0x2421024, +0x10400004, 0x0, 0x97a20018, 0x10000004, +0xa7a20018, 0x97a20018, 0x34420100, 0xa7a20018, +0x3c020001, 0x2421024, 0x10400004, 0x0, +0x97a20018, 0x10000004, 0xa7a20018, 0x97a20018, +0x34422000, 0xa7a20018, 0x97a60018, 0x2021, +0x2821, 0xc0053b9, 0x0, 0x8f830054, +0x24020004, 0x3c010002, 0xac228500, 0x3c010002, +0xac238658, 0x10000018, 0x0, 0x8f830054, +0x3c020002, 0x8c428658, 0x2463ff9c, 0x431023, +0x2c420064, 0x14400010, 0x0, 0x8f820220, +0x24030005, 0x3c010002, 0xac238500, 0x3c03f700, +0x431025, 0xaf820220, 0x10000007, 0x0, +0x24020006, 0x3c010002, 0xac228500, 0x24020011, +0x3c010002, 0xac2284fc, 0x8fbf0034, 0x8fb20030, 0x8fb1002c, 0x8fb00028, 0x3e00008, 0x27bd0038, 0x27bdffd8, 0xafb00018, 0x808021, 0xafb1001c, 0x8821, 0x32024000, 0x10400013, 0xafbf0020, @@ -3946,637 +4322,586 @@ 0x34714000, 0x3c020002, 0x2021024, 0x14400002, 0x34716000, 0x34714040, 0x2021, 0x2821, 0x10000036, 0x2203021, 0x32021000, 0x10400035, -0x2021, 0x2821, 0xc004e0b, 0x24060040, -0x24040018, 0x2821, 0xc004e0b, 0x24060c00, -0x24040017, 0x2821, 0xc004e0b, 0x24060400, -0x24040016, 0x2821, 0xc004e0b, 0x24060006, -0x24040017, 0x2821, 0xc004e0b, 0x24062500, -0x24040016, 0x2821, 0xc004e0b, 0x24060006, -0x24040017, 0x2821, 0xc004e0b, 0x24064600, -0x24040016, 0x2821, 0xc004e0b, 0x24060006, -0x24040017, 0x2821, 0xc004e0b, 0x24066700, -0x24040016, 0x2821, 0xc004e0b, 0x24060006, -0x2404001f, 0x2821, 0xc004e0b, 0x24060010, -0x24040009, 0x2821, 0xc004e0b, 0x24061500, -0x24040009, 0x2821, 0x24061d00, 0xc004e0b, -0x0, 0x3c040001, 0x24846cb0, 0x3c05000e, -0x34a50100, 0x2003021, 0x2203821, 0xafa00010, -0xc002b37, 0xafa00014, 0x8fbf0020, 0x8fb1001c, -0x8fb00018, 0x3e00008, 0x27bd0028, 0x8f850044, -0x8f820044, 0x3c030001, 0x431025, 0x3c030008, -0xaf820044, 0x8f840054, 0x8f820054, 0xa32824, -0x10000002, 0x24840001, 0x8f820054, 0x821023, -0x2c420002, 0x1440fffc, 0x0, 0x8f820044, +0x2021, 0x2821, 0xc0053b9, 0x24060040, +0x24040018, 0x2821, 0xc0053b9, 0x24060c00, +0x24040017, 0x2821, 0xc0053b9, 0x24060400, +0x24040016, 0x2821, 0xc0053b9, 0x24060006, +0x24040017, 0x2821, 0xc0053b9, 0x24062500, +0x24040016, 0x2821, 0xc0053b9, 0x24060006, +0x24040017, 0x2821, 0xc0053b9, 0x24064600, +0x24040016, 0x2821, 0xc0053b9, 0x24060006, +0x24040017, 0x2821, 0xc0053b9, 0x24066700, +0x24040016, 0x2821, 0xc0053b9, 0x24060006, +0x2404001f, 0x2821, 0xc0053b9, 0x24060010, +0x24040009, 0x2821, 0xc0053b9, 0x24061500, +0x24040009, 0x2821, 0x24061d00, 0xc0053b9, +0x0, 0x3c040002, 0x24848170, 0x3c05000e, +0x3c020002, 0x8c4284cc, 0x34a50100, 0x2003021, +0x2203821, 0xafa00014, 0xc002d3b, 0xafa20010, +0x8fbf0020, 0x8fb1001c, 0x8fb00018, 0x3e00008, +0x27bd0028, 0x8f840044, 0x8f820044, 0x3c030001, +0x431025, 0xaf820044, 0x8f820044, 0x3c03fffe, +0x3463ffff, 0x431024, 0xaf820044, 0x3c020008, +0x3e00008, 0x821024, 0x8f830044, 0x3c02fff0, +0x3442ffff, 0x42480, 0x621824, 0x3c020002, +0x822025, 0x641825, 0xaf830044, 0x8f820044, 0x3c03fffe, 0x3463ffff, 0x431024, 0xaf820044, -0x8f830054, 0x8f820054, 0x10000002, 0x24630001, -0x8f820054, 0x621023, 0x2c420002, 0x1440fffc, -0x0, 0x3e00008, 0xa01021, 0x8f830044, -0x3c02fff0, 0x3442ffff, 0x42480, 0x621824, -0x3c020002, 0x822025, 0x641825, 0xaf830044, -0x8f820044, 0x3c03fffe, 0x3463ffff, 0x431024, -0xaf820044, 0x8f830054, 0x8f820054, 0x10000002, -0x24630001, 0x8f820054, 0x621023, 0x2c420002, -0x1440fffc, 0x0, 0x8f820044, 0x3c030001, -0x431025, 0xaf820044, 0x8f830054, 0x8f820054, -0x10000002, 0x24630001, 0x8f820054, 0x621023, -0x2c420002, 0x1440fffc, 0x0, 0x3e00008, -0x0, 0x8f820044, 0x2403ff7f, 0x431024, -0xaf820044, 0x8f830054, 0x8f820054, 0x10000002, -0x24630001, 0x8f820054, 0x621023, 0x2c420002, -0x1440fffc, 0x0, 0x8f820044, 0x34420080, -0xaf820044, 0x8f830054, 0x8f820054, 0x10000002, -0x24630001, 0x8f820054, 0x621023, 0x2c420002, -0x1440fffc, 0x0, 0x3e00008, 0x0, -0x8f820044, 0x3c03fff0, 0x3463ffff, 0x431024, -0xaf820044, 0x8f820044, 0x3c030001, 0x431025, -0xaf820044, 0x8f830054, 0x8f820054, 0x10000002, -0x24630001, 0x8f820054, 0x621023, 0x2c420002, -0x1440fffc, 0x0, 0x8f820044, 0x3c03fffe, -0x3463ffff, 0x431024, 0xaf820044, 0x8f830054, -0x8f820054, 0x10000002, 0x24630001, 0x8f820054, -0x621023, 0x2c420002, 0x1440fffc, 0x0, -0x3e00008, 0x0, 0x27bdffc8, 0xafb30024, -0x809821, 0xafbe002c, 0xa0f021, 0xafb20020, -0xc09021, 0x33c2ffff, 0xafbf0030, 0xafb50028, -0xafb1001c, 0xafb00018, 0x14400034, 0xa7b20010, -0x3271ffff, 0x27b20010, 0x8021, 0xc004da8, -0x24040001, 0x26100001, 0x2e020020, 0x1440fffb, -0x0, 0xc004da8, 0x2021, 0xc004da8, -0x24040001, 0xc004da8, 0x2021, 0xc004da8, -0x24040001, 0x24100010, 0x32020001, 0x10400002, -0x2021, 0x24040001, 0xc004da8, 0x108042, -0x1600fffa, 0x32020001, 0x24100010, 0x2301024, -0x10400002, 0x2021, 0x24040001, 0xc004da8, -0x108042, 0x1600fffa, 0x2301024, 0xc004da8, -0x24040001, 0xc004da8, 0x2021, 0x34108000, -0x96420000, 0x501024, 0x10400002, 0x2021, -0x24040001, 0xc004da8, 0x108042, 0x12000075, -0x0, 0x1000fff6, 0x0, 0x3275ffff, -0x27b10010, 0xa7a00010, 0x8021, 0xc004da8, -0x24040001, 0x26100001, 0x2e020020, 0x1440fffb, -0x0, 0xc004da8, 0x2021, 0xc004da8, -0x24040001, 0xc004da8, 0x24040001, 0xc004da8, -0x2021, 0x24100010, 0x32020001, 0x10400002, -0x2021, 0x24040001, 0xc004da8, 0x108042, -0x1600fffa, 0x32020001, 0x24100010, 0x2b01024, -0x10400002, 0x2021, 0x24040001, 0xc004da8, -0x108042, 0x1600fffa, 0x2b01024, 0xc004de9, -0x34108000, 0xc004de9, 0x0, 0xc004d88, -0x0, 0x50400005, 0x108042, 0x96220000, -0x501025, 0xa6220000, 0x108042, 0x1600fff7, -0x0, 0xc004de9, 0x0, 0x33c5ffff, -0x24020001, 0x54a20004, 0x24020002, 0x97a20010, -0x10000006, 0x521025, 0x14a20006, 0x3271ffff, -0x97a20010, 0x121827, 0x431024, 0xa7a20010, -0x3271ffff, 0x27b20010, 0x8021, 0xc004da8, -0x24040001, 0x26100001, 0x2e020020, 0x1440fffb, -0x0, 0xc004da8, 0x2021, 0xc004da8, -0x24040001, 0xc004da8, 0x2021, 0xc004da8, -0x24040001, 0x24100010, 0x32020001, 0x10400002, -0x2021, 0x24040001, 0xc004da8, 0x108042, -0x1600fffa, 0x32020001, 0x24100010, 0x2301024, -0x10400002, 0x2021, 0x24040001, 0xc004da8, -0x108042, 0x1600fffa, 0x2301024, 0xc004da8, -0x24040001, 0xc004da8, 0x2021, 0x34108000, -0x96420000, 0x501024, 0x10400002, 0x2021, -0x24040001, 0xc004da8, 0x108042, 0x1600fff8, -0x0, 0xc004de9, 0x0, 0x8fbf0030, -0x8fbe002c, 0x8fb50028, 0x8fb30024, 0x8fb20020, -0x8fb1001c, 0x8fb00018, 0x3e00008, 0x27bd0038, -0x0, 0x0, 0x0, 0x27bdffe8, -0xafbf0010, 0x8ee304b8, 0x24020008, 0x146201e0, -0x0, 0x3c020001, 0x8c426fdc, 0x14400005, -0x0, 0xc003dab, 0x8f840224, 0x100001d8, +0x8f820044, 0x3c030001, 0x431025, 0x3e00008, +0xaf820044, 0x8f820044, 0x2403ff7f, 0x431024, +0xaf820044, 0x8f820044, 0x34420080, 0x3e00008, +0xaf820044, 0x8f820044, 0x3c03fff0, 0x3463ffff, +0x431024, 0xaf820044, 0x8f820044, 0x3c030001, +0x431025, 0xaf820044, 0x8f820044, 0x3c03fffe, +0x3463ffff, 0x431024, 0x3e00008, 0xaf820044, +0x27bdffc8, 0xafb30024, 0x809821, 0xafbe002c, +0xa0f021, 0xafb20020, 0xc09021, 0x33c2ffff, +0xafbf0030, 0xafb50028, 0xafb1001c, 0xafb00018, +0x14400034, 0xa7b20010, 0x3271ffff, 0x27b20010, +0x8021, 0xc00538f, 0x24040001, 0x26100001, +0x2e020020, 0x1440fffb, 0x0, 0xc00538f, +0x2021, 0xc00538f, 0x24040001, 0xc00538f, +0x2021, 0xc00538f, 0x24040001, 0x24100010, +0x32020001, 0x10400002, 0x2021, 0x24040001, +0xc00538f, 0x108042, 0x1600fffa, 0x32020001, +0x24100010, 0x2301024, 0x10400002, 0x2021, +0x24040001, 0xc00538f, 0x108042, 0x1600fffa, +0x2301024, 0xc00538f, 0x24040001, 0xc00538f, +0x2021, 0x34108000, 0x96420000, 0x501024, +0x10400002, 0x2021, 0x24040001, 0xc00538f, +0x108042, 0x12000075, 0x0, 0x1000fff6, +0x0, 0x3275ffff, 0x27b10010, 0xa7a00010, +0x8021, 0xc00538f, 0x24040001, 0x26100001, +0x2e020020, 0x1440fffb, 0x0, 0xc00538f, +0x2021, 0xc00538f, 0x24040001, 0xc00538f, +0x24040001, 0xc00538f, 0x2021, 0x24100010, +0x32020001, 0x10400002, 0x2021, 0x24040001, +0xc00538f, 0x108042, 0x1600fffa, 0x32020001, +0x24100010, 0x2b01024, 0x10400002, 0x2021, +0x24040001, 0xc00538f, 0x108042, 0x1600fffa, +0x2b01024, 0xc0053aa, 0x34108000, 0xc0053aa, +0x0, 0xc005382, 0x0, 0x50400005, +0x108042, 0x96220000, 0x501025, 0xa6220000, +0x108042, 0x1600fff7, 0x0, 0xc0053aa, +0x0, 0x33c5ffff, 0x24020001, 0x54a20004, +0x24020002, 0x97a20010, 0x10000006, 0x521025, +0x14a20006, 0x3271ffff, 0x97a20010, 0x121827, +0x431024, 0xa7a20010, 0x3271ffff, 0x27b20010, +0x8021, 0xc00538f, 0x24040001, 0x26100001, +0x2e020020, 0x1440fffb, 0x0, 0xc00538f, +0x2021, 0xc00538f, 0x24040001, 0xc00538f, +0x2021, 0xc00538f, 0x24040001, 0x24100010, +0x32020001, 0x10400002, 0x2021, 0x24040001, +0xc00538f, 0x108042, 0x1600fffa, 0x32020001, +0x24100010, 0x2301024, 0x10400002, 0x2021, +0x24040001, 0xc00538f, 0x108042, 0x1600fffa, +0x2301024, 0xc00538f, 0x24040001, 0xc00538f, +0x2021, 0x34108000, 0x96420000, 0x501024, +0x10400002, 0x2021, 0x24040001, 0xc00538f, +0x108042, 0x1600fff8, 0x0, 0xc0053aa, +0x0, 0x8fbf0030, 0x8fbe002c, 0x8fb50028, +0x8fb30024, 0x8fb20020, 0x8fb1001c, 0x8fb00018, +0x3e00008, 0x27bd0038, 0x27bdffe8, 0xafbf0010, +0x8ee304b8, 0x24020008, 0x146201f1, 0x0, +0x3c020002, 0x8c42863c, 0x14400006, 0x0, +0x8f840224, 0xc004343, 0x0, 0x100001e8, 0x0, 0x8f820220, 0x3c030008, 0x431024, -0x10400026, 0x24020001, 0x8f840224, 0x8f820220, -0x3c030400, 0x431024, 0x10400006, 0x0, -0x3c010002, 0xac209060, 0x3c010002, 0x1000000b, -0xac209080, 0x3c030002, 0x24639060, 0x8c620000, -0x24420001, 0xac620000, 0x2c420002, 0x14400003, -0x24020001, 0x3c010002, 0xac229080, 0x3c020002, -0x8c429080, 0x10400006, 0x30820040, 0x10400004, -0x24020001, 0x3c010002, 0x10000003, 0xac229084, -0x3c010002, 0xac209084, 0x3c010002, 0xac24905c, -0x3c010002, 0x1000000b, 0xac209090, 0x3c010002, -0xac229090, 0x3c010002, 0xac209080, 0x3c010002, -0xac209060, 0x3c010002, 0xac209084, 0x3c010002, -0xac20905c, 0x3c030002, 0x8c639050, 0x3c020002, -0x8c429054, 0x50620004, 0x2463ffff, 0x3c010002, -0xac239054, 0x2463ffff, 0x2c62000e, 0x10400194, -0x31080, 0x3c010001, 0x220821, 0x8c226cc0, -0x400008, 0x0, 0x24020002, 0x3c010002, -0xac209080, 0x3c010002, 0xac209060, 0x3c010002, -0xac20905c, 0x3c010002, 0xac209084, 0x3c010002, -0xac209078, 0x3c010002, 0xac209070, 0xaf800224, -0x3c010002, 0xac229050, 0x3c020002, 0x8c429090, -0x1440004f, 0x3c02fdff, 0x3442ffff, 0xc003dab, -0x282a024, 0xaf800204, 0x8f820200, 0x2403fffd, -0x431024, 0xaf820200, 0x3c010002, 0xac2090a0, -0x8f830054, 0x3c020002, 0x8c429078, 0x24040001, -0x3c010002, 0xac24908c, 0x24420001, 0x3c010002, -0xac229078, 0x2c420004, 0x3c010002, 0xac239074, -0x14400006, 0x24020003, 0x3c010001, 0xac246e5c, -0x3c010002, 0x1000015e, 0xac209078, 0x3c010002, -0x1000015b, 0xac229050, 0x8f830054, 0x3c020002, -0x8c429074, 0x2463d8f0, 0x431023, 0x2c422710, -0x14400003, 0x24020004, 0x3c010002, 0xac229050, -0x3c020002, 0x8c429090, 0x14400021, 0x3c02fdff, -0x3442ffff, 0x1000014a, 0x282a024, 0x3c040001, -0x8c846fe0, 0x3c010002, 0xc0050b4, 0xac209068, -0x3c020002, 0x8c42909c, 0xaf820204, 0x3c020002, -0x8c429090, 0x14400012, 0x3c03fdff, 0x8f820204, -0x3463ffff, 0x30420030, 0x1440012f, 0x283a024, -0x3c030002, 0x8c63909c, 0x24020005, 0x3c010002, -0xac229050, 0x3c010002, 0x10000131, 0xac2390a0, -0x3c020002, 0x8c429090, 0x10400010, 0x3c02fdff, -0x3c020001, 0x8c426efc, 0x24420001, 0x3c010001, -0xac226efc, 0x2c420002, 0x14400125, 0x24020001, -0x3c010001, 0xac226f04, 0x3c010001, 0xac206efc, -0x3c010001, 0x1000011e, 0xac226e5c, 0x3c030002, -0x8c639080, 0x3442ffff, 0x10600119, 0x282a024, -0x3c020002, 0x8c42905c, 0x10400115, 0x0, -0x3c010002, 0xac229088, 0x24020003, 0x3c010002, -0xac229060, 0x100000b8, 0x24020006, 0x3c010002, -0xac209068, 0x8f820204, 0x34420040, 0xaf820204, -0x3c020002, 0x8c4290a0, 0x24030007, 0x3c010002, -0xac239050, 0x34420040, 0x3c010002, 0xac2290a0, -0x3c020002, 0x8c429080, 0x10400005, 0x0, -0x3c020002, 0x8c42905c, 0x104000f0, 0x24020002, -0x3c050002, 0x24a59060, 0x8ca20000, 0x2c424e21, -0x104000ea, 0x24020002, 0x3c020002, 0x8c429084, -0x104000ef, 0x2404ffbf, 0x3c020002, 0x8c42905c, -0x3c030002, 0x8c639088, 0x441024, 0x641824, -0x10430004, 0x24020001, 0x3c010002, 0x100000e4, -0xac229050, 0x24020003, 0xaca20000, 0x24020008, -0x3c010002, 0xac229050, 0x3c020002, 0x8c42908c, -0x1040000c, 0x24020001, 0x3c040002, 0xc0050c1, -0x8c84905c, 0x3c020002, 0x8c4290a8, 0x14400005, -0x24020001, 0x3c020002, 0x8c4290a4, 0x10400006, -0x24020001, 0x3c010001, 0xac226e5c, 0x3c010002, -0x100000cb, 0xac209078, 0x3c020002, 0x8c429070, -0x3c030002, 0x8c63905c, 0x2c420001, 0x210c0, -0x30630008, 0x3c010002, 0xac229070, 0x3c010002, -0xac23906c, 0x8f830054, 0x24020009, 0x3c010002, -0xac229050, 0x3c010002, 0x100000b9, 0xac239074, -0x8f830054, 0x3c020002, 0x8c429074, 0x2463d8f0, -0x431023, 0x2c422710, 0x1440009f, 0x0, -0x3c020002, 0x8c429080, 0x10400005, 0x0, -0x3c020002, 0x8c42905c, 0x104000a0, 0x24020002, -0x3c030002, 0x24639060, 0x8c620000, 0x2c424e21, -0x1040009a, 0x24020002, 0x3c020002, 0x8c42908c, -0x1040000e, 0x0, 0x3c020002, 0x8c42905c, -0x3c010002, 0xac20908c, 0x30420080, 0x1040002f, +0x10400029, 0x24020001, 0x8f840224, 0x8f820220, +0x3c030400, 0x431024, 0x10400007, 0x0, +0x3c010002, 0xac20a6c0, 0x3c010002, 0xac20a6e0, +0x1000000b, 0x0, 0x3c030002, 0x2463a6c0, +0x8c620000, 0x24420001, 0xac620000, 0x2c420002, +0x14400003, 0x24020001, 0x3c010002, 0xac22a6e0, +0x3c020002, 0x8c42a6e0, 0x10400007, 0x30820040, +0x10400005, 0x24020001, 0x3c010002, 0xac22a6e4, +0x10000003, 0x0, 0x3c010002, 0xac20a6e4, +0x3c010002, 0xac24a6bc, 0x3c010002, 0xac20a6f0, +0x1000000b, 0x0, 0x3c010002, 0xac22a6f0, +0x3c010002, 0xac20a6e0, 0x3c010002, 0xac20a6c0, +0x3c010002, 0xac20a6e4, 0x3c010002, 0xac20a6bc, +0x3c030002, 0x8c63a6b0, 0x3c020002, 0x8c42a6b4, +0x50620004, 0x2463ffff, 0x3c010002, 0xac23a6b4, +0x2463ffff, 0x2c62000e, 0x104001a1, 0x31080, +0x3c010002, 0x220821, 0x8c228190, 0x400008, +0x0, 0x24020002, 0x3c010002, 0xac20a6e0, +0x3c010002, 0xac20a6c0, 0x3c010002, 0xac20a6bc, +0x3c010002, 0xac20a6e4, 0x3c010002, 0xac20a6d8, +0x3c010002, 0xac20a6d0, 0xaf800224, 0x3c010002, +0xac22a6b0, 0x3c020002, 0x8c42a6f0, 0x14400053, +0x3c02fdff, 0x3442ffff, 0xc004343, 0x282a024, +0xaf800204, 0x8f820200, 0x2403fffd, 0x431024, +0xaf820200, 0x3c010002, 0xac20a700, 0x8f830054, +0x3c020002, 0x8c42a6d8, 0x24040001, 0x3c010002, +0xac24a6ec, 0x24420001, 0x3c010002, 0xac22a6d8, +0x2c420004, 0x3c010002, 0xac23a6d4, 0x14400007, +0x24020003, 0x3c010002, 0xac2484d0, 0x3c010002, +0xac20a6d8, 0x1000016a, 0x0, 0x3c010002, +0xac22a6b0, 0x10000166, 0x0, 0x8f830054, +0x3c020002, 0x8c42a6d4, 0x2463d8f0, 0x431023, +0x2c422710, 0x14400003, 0x24020004, 0x3c010002, +0xac22a6b0, 0x3c020002, 0x8c42a6f0, 0x14400023, +0x3c02fdff, 0x3442ffff, 0x10000155, 0x282a024, +0x3c040002, 0x8c848640, 0x3c010002, 0xac20a6c8, +0xc005670, 0x0, 0x3c020002, 0x8c42a6fc, +0xaf820204, 0x3c020002, 0x8c42a6f0, 0x14400013, +0x3c03fdff, 0x8f820204, 0x3463ffff, 0x30420030, +0x14400138, 0x283a024, 0x3c030002, 0x8c63a6fc, +0x24020005, 0x3c010002, 0xac22a6b0, 0x3c010002, +0xac23a700, 0x1000013a, 0x0, 0x3c020002, +0x8c42a6f0, 0x10400011, 0x3c02fdff, 0x3c020002, +0x8c428560, 0x24420001, 0x3c010002, 0xac228560, +0x2c420002, 0x1440012e, 0x24020001, 0x3c010002, +0xac228568, 0x3c010002, 0xac208560, 0x3c010002, +0xac2284d0, 0x10000126, 0x0, 0x3c030002, +0x8c63a6e0, 0x3442ffff, 0x10600121, 0x282a024, +0x3c020002, 0x8c42a6bc, 0x1040011d, 0x0, +0x3c010002, 0xac22a6e8, 0x24020003, 0x3c010002, +0xac22a6c0, 0x100000bd, 0x24020006, 0x3c010002, +0xac20a6c8, 0x8f820204, 0x34420040, 0xaf820204, +0x3c020002, 0x8c42a700, 0x24030007, 0x3c010002, +0xac23a6b0, 0x34420040, 0x3c010002, 0xac22a700, +0x3c020002, 0x8c42a6e0, 0x10400005, 0x0, +0x3c020002, 0x8c42a6bc, 0x104000f7, 0x24020002, +0x3c050002, 0x24a5a6c0, 0x8ca20000, 0x2c424e21, +0x104000f1, 0x24020002, 0x3c020002, 0x8c42a6e4, +0x104000f7, 0x2404ffbf, 0x3c020002, 0x8c42a6bc, +0x3c030002, 0x8c63a6e8, 0x441024, 0x641824, +0x10430005, 0x24020001, 0x3c010002, 0xac22a6b0, +0x100000eb, 0x0, 0x24020003, 0xaca20000, +0x24020008, 0x3c010002, 0xac22a6b0, 0x3c020002, +0x8c42a6ec, 0x1040000d, 0x24020001, 0x3c040002, +0x8c84a6bc, 0xc00567d, 0x0, 0x3c020002, +0x8c42a708, 0x14400005, 0x24020001, 0x3c020002, +0x8c42a704, 0x10400007, 0x24020001, 0x3c010002, +0xac2284d0, 0x3c010002, 0xac20a6d8, 0x100000d0, +0x0, 0x3c020002, 0x8c42a6d0, 0x3c030002, +0x8c63a6bc, 0x2c420001, 0x210c0, 0x30630008, +0x3c010002, 0xac22a6d0, 0x3c010002, 0xac23a6cc, +0x8f830054, 0x24020009, 0x3c010002, 0xac22a6b0, +0x3c010002, 0xac23a6d4, 0x100000bd, 0x0, +0x8f830054, 0x3c020002, 0x8c42a6d4, 0x2463d8f0, +0x431023, 0x2c422710, 0x144000a2, 0x0, +0x3c020002, 0x8c42a6e0, 0x10400005, 0x0, +0x3c020002, 0x8c42a6bc, 0x104000a3, 0x24020002, +0x3c030002, 0x2463a6c0, 0x8c620000, 0x2c424e21, +0x1040009d, 0x24020002, 0x3c020002, 0x8c42a6ec, +0x1040000e, 0x0, 0x3c020002, 0x8c42a6bc, +0x3c010002, 0xac20a6ec, 0x30420080, 0x1040002f, 0x2402000c, 0x8f820204, 0x30420080, 0x1440000c, 0x24020003, 0x10000029, 0x2402000c, 0x3c020002, -0x8c42905c, 0x30420080, 0x14400005, 0x24020003, +0x8c42a6bc, 0x30420080, 0x14400005, 0x24020003, 0x8f820204, 0x30420080, 0x1040001f, 0x24020003, -0xac620000, 0x2402000a, 0x3c010002, 0xac229050, -0x3c040002, 0x24849098, 0x8c820000, 0x3c030002, -0x8c639070, 0x431025, 0xaf820204, 0x8c830000, -0x3c040002, 0x8c849070, 0x2402000b, 0x3c010002, -0xac229050, 0x641825, 0x3c010002, 0xac2390a0, -0x3c050002, 0x24a59060, 0x8ca20000, 0x2c424e21, -0x10400066, 0x24020002, 0x3c020002, 0x8c429090, -0x10400005, 0x0, 0x2402000c, 0x3c010002, -0x10000067, 0xac229050, 0x3c020002, 0x8c429080, -0x10400063, 0x0, 0x3c040002, 0x8c84905c, -0x10800055, 0x30820008, 0x3c030002, 0x8c63906c, -0x1062005b, 0x24020003, 0x3c010002, 0xac249088, -0xaca20000, 0x24020006, 0x3c010002, 0x10000054, -0xac229050, 0x8f820200, 0x34420002, 0xaf820200, -0x8f830054, 0x2402000d, 0x3c010002, 0xac229050, -0x3c010002, 0xac239074, 0x8f830054, 0x3c020002, -0x8c429074, 0x2463d8f0, 0x431023, 0x2c422710, -0x14400031, 0x0, 0x3c020002, 0x8c429090, -0x10400020, 0x2402000e, 0x3c030002, 0x8c6390a4, -0x3c010002, 0x14600015, 0xac229050, 0xc003e69, -0x0, 0x3c050001, 0x8ca56e58, 0xc0052cb, -0x2021, 0x3c030001, 0x8c636e58, 0x24020004, -0x14620005, 0x2403fffb, 0x3c020001, 0x8c426e54, -0x10000003, 0x2403fff7, 0x3c020001, 0x8c426e54, -0x431024, 0x3c010001, 0xac226e54, 0x8f830224, -0x3c020200, 0x3c010002, 0xac2390ac, 0x10000020, -0x282a025, 0x3c020002, 0x8c429080, 0x10400005, -0x0, 0x3c020002, 0x8c42905c, 0x1040000f, -0x24020002, 0x3c020002, 0x8c429060, 0x2c424e21, -0x1040000a, 0x24020002, 0x3c020002, 0x8c429080, -0x1040000f, 0x0, 0x3c020002, 0x8c42905c, -0x1440000b, 0x0, 0x24020002, 0x3c010002, -0x10000007, 0xac229050, 0x3c020002, 0x8c429080, -0x10400003, 0x0, 0xc003dab, 0x0, +0xac620000, 0x2402000a, 0x3c010002, 0xac22a6b0, +0x3c040002, 0x2484a6f8, 0x8c820000, 0x3c030002, +0x8c63a6d0, 0x431025, 0xaf820204, 0x8c830000, +0x3c040002, 0x8c84a6d0, 0x2402000b, 0x3c010002, +0xac22a6b0, 0x641825, 0x3c010002, 0xac23a700, +0x3c050002, 0x24a5a6c0, 0x8ca20000, 0x2c424e21, +0x10400069, 0x24020002, 0x3c020002, 0x8c42a6f0, +0x10400006, 0x0, 0x2402000c, 0x3c010002, +0xac22a6b0, 0x1000006a, 0x0, 0x3c020002, +0x8c42a6e0, 0x10400066, 0x0, 0x3c040002, +0x8c84a6bc, 0x10800057, 0x30820008, 0x3c030002, +0x8c63a6cc, 0x1062005e, 0x24020003, 0x3c010002, +0xac24a6e8, 0xaca20000, 0x24020006, 0x3c010002, +0xac22a6b0, 0x10000056, 0x0, 0x8f820200, +0x34420002, 0xaf820200, 0x8f830054, 0x2402000d, +0x3c010002, 0xac22a6b0, 0x3c010002, 0xac23a6d4, +0x8f830054, 0x3c020002, 0x8c42a6d4, 0x2463d8f0, +0x431023, 0x2c422710, 0x14400032, 0x0, +0x3c020002, 0x8c42a6f0, 0x10400021, 0x2402000e, +0x3c030002, 0x8c63a704, 0x3c010002, 0xac22a6b0, +0x14600015, 0x0, 0xc004401, 0x0, +0x3c050002, 0x8ca584cc, 0xc005897, 0x2021, +0x3c030002, 0x8c6384cc, 0x24020004, 0x14620005, +0x2403fffb, 0x3c020002, 0x8c4284c8, 0x10000003, +0x2403fff7, 0x3c020002, 0x8c4284c8, 0x431024, +0x3c010002, 0xac2284c8, 0x8f830224, 0x3c020200, +0x3c010002, 0xac23a70c, 0x10000021, 0x282a025, +0x3c020002, 0x8c42a6e0, 0x10400005, 0x0, +0x3c020002, 0x8c42a6bc, 0x1040000f, 0x24020002, +0x3c020002, 0x8c42a6c0, 0x2c424e21, 0x1040000a, +0x24020002, 0x3c020002, 0x8c42a6e0, 0x10400010, +0x0, 0x3c020002, 0x8c42a6bc, 0x1440000c, +0x0, 0x24020002, 0x3c010002, 0xac22a6b0, +0x10000007, 0x0, 0x3c020002, 0x8c42a6e0, +0x10400003, 0x0, 0xc004343, 0x0, 0x8f820220, 0x3c03f700, 0x431025, 0xaf820220, 0x8fbf0010, 0x3e00008, 0x27bd0018, 0x3c030002, -0x246390a8, 0x8c620000, 0x10400005, 0x34422000, -0x3c010002, 0xac22909c, 0x10000003, 0xac600000, -0x3c010002, 0xac24909c, 0x3e00008, 0x0, +0x2463a708, 0x8c620000, 0x10400005, 0x34422000, +0x3c010002, 0xac22a6fc, 0x10000003, 0xac600000, +0x3c010002, 0xac24a6fc, 0x3e00008, 0x0, 0x27bdffe0, 0x30820030, 0xafbf0018, 0x3c010002, -0xac2290a4, 0x14400067, 0x3c02ffff, 0x34421f0e, -0x821024, 0x14400061, 0x24020030, 0x30822000, -0x1040005d, 0x30838000, 0x31a02, 0x30820001, -0x21200, 0x3c040001, 0x8c846fe0, 0x621825, -0x331c2, 0x3c030001, 0x24636f08, 0x30828000, +0xac22a704, 0x1440006b, 0x3c02ffff, 0x34421f0e, +0x821024, 0x14400065, 0x24020030, 0x30822000, +0x10400061, 0x30838000, 0x31a02, 0x30820001, +0x21200, 0x3c040002, 0x8c848640, 0x621825, +0x331c2, 0x3c030002, 0x2463856c, 0x30828000, 0x21202, 0x30840001, 0x42200, 0x441025, 0x239c2, 0x61080, 0x431021, 0x471021, -0x90430000, 0x24020001, 0x10620025, 0x0, -0x10600007, 0x24020002, 0x10620013, 0x24020003, -0x1062002c, 0x3c05000f, 0x10000037, 0x0, +0x90430000, 0x24020001, 0x10620027, 0x0, +0x10600007, 0x24020002, 0x10620014, 0x24020003, +0x1062002f, 0x3c05000f, 0x1000003b, 0x0, 0x8f820200, 0x2403feff, 0x431024, 0xaf820200, 0x8f820220, 0x3c03fffe, 0x3463ffff, 0x431024, -0xaf820220, 0x3c010002, 0xac2090c4, 0x3c010002, -0x10000034, 0xac2090cc, 0x8f820200, 0x34420100, -0xaf820200, 0x8f820220, 0x3c03fffe, 0x3463ffff, -0x431024, 0xaf820220, 0x24020100, 0x3c010002, -0xac2290c4, 0x3c010002, 0x10000026, 0xac2090cc, -0x8f820200, 0x2403feff, 0x431024, 0xaf820200, -0x8f820220, 0x3c030001, 0x431025, 0xaf820220, -0x3c010002, 0xac2090c4, 0x3c010002, 0x10000019, -0xac2390cc, 0x8f820200, 0x34420100, 0xaf820200, -0x8f820220, 0x3c030001, 0x431025, 0xaf820220, -0x24020100, 0x3c010002, 0xac2290c4, 0x3c010002, -0x1000000c, 0xac2390cc, 0x34a5ffff, 0x3c040001, -0x24846cf8, 0xafa30010, 0xc002b37, 0xafa00014, +0xaf820220, 0x3c010002, 0xac20a724, 0x3c010002, +0xac20a72c, 0x10000037, 0x0, 0x8f820200, +0x34420100, 0xaf820200, 0x8f820220, 0x3c03fffe, +0x3463ffff, 0x431024, 0xaf820220, 0x24020100, +0x3c010002, 0xac22a724, 0x3c010002, 0xac20a72c, +0x10000028, 0x0, 0x8f820200, 0x2403feff, +0x431024, 0xaf820200, 0x8f820220, 0x3c030001, +0x431025, 0xaf820220, 0x3c010002, 0xac20a724, +0x3c010002, 0xac23a72c, 0x1000001a, 0x0, +0x8f820200, 0x34420100, 0xaf820200, 0x8f820220, +0x3c030001, 0x431025, 0xaf820220, 0x24020100, +0x3c010002, 0xac22a724, 0x3c010002, 0xac23a72c, +0x1000000c, 0x0, 0x34a5ffff, 0x3c040002, +0x248481c8, 0xafa30010, 0xc002d3b, 0xafa00014, 0x10000004, 0x0, 0x24020030, 0x3c010002, -0xac2290a8, 0x8fbf0018, 0x3e00008, 0x27bd0020, -0x0, 0x0, 0x0, 0x27bdffc8, -0xafb20028, 0x809021, 0xafb3002c, 0xa09821, -0xafb00020, 0xc08021, 0x3c040001, 0x24846d10, -0x3c050009, 0x3c020001, 0x8c426e58, 0x34a59001, -0x2403021, 0x2603821, 0xafbf0030, 0xafb10024, -0xa7a0001a, 0xafb00014, 0xc002b37, 0xafa20010, -0x24020002, 0x12620083, 0x2e620003, 0x10400005, -0x24020001, 0x1262000a, 0x0, 0x10000173, -0x0, 0x24020004, 0x126200f8, 0x24020008, -0x126200f7, 0x3c02ffec, 0x1000016c, 0x0, -0x3c020001, 0x8c426e54, 0x30420002, 0x14400004, -0x128940, 0x3c02fffb, 0x3442ffff, 0x2028024, -0x3c010002, 0x310821, 0xac3090bc, 0x3c024000, -0x2021024, 0x1040004e, 0x1023c2, 0x30840030, -0x101382, 0x3042001c, 0x3c030001, 0x24636e98, -0x431021, 0x823821, 0x3c020020, 0x2021024, -0x10400006, 0x24020100, 0x3c010002, 0x310821, -0xac2290c0, 0x10000005, 0x3c020080, 0x3c010002, -0x310821, 0xac2090c0, 0x3c020080, 0x2021024, -0x10400006, 0x121940, 0x3c020001, 0x3c010002, -0x230821, 0x10000005, 0xac2290c8, 0x121140, -0x3c010002, 0x220821, 0xac2090c8, 0x94e40000, -0x3c030001, 0x8c637000, 0x24020005, 0x10620010, -0xa7a40018, 0x32024000, 0x10400002, 0x34824000, -0xa7a20018, 0x24040001, 0x94e20002, 0x24050004, -0x24e60002, 0x34420001, 0xc0045ee, 0xa4e20002, -0x24040001, 0x2821, 0xc0045ee, 0x27a60018, -0x3c020001, 0x8c426e58, 0x24110001, 0x3c010001, -0xac316e64, 0x14530004, 0x32028000, 0xc003dab, -0x0, 0x32028000, 0x1040011c, 0x0, -0xc003dab, 0x0, 0x3c030001, 0x8c637000, -0x24020005, 0x10620115, 0x24020002, 0x3c010001, -0xac316e5c, 0x3c010001, 0x10000110, 0xac226e58, -0x24040001, 0x24050004, 0x27b0001a, 0xc0045ee, -0x2003021, 0x24040001, 0x2821, 0xc0045ee, -0x2003021, 0x3c020002, 0x511021, 0x8c4290b4, -0x3c040001, 0x8c846e58, 0x3c03bfff, 0x3463ffff, -0x3c010001, 0xac336e64, 0x431024, 0x3c010002, -0x310821, 0x109300f7, 0xac2290b4, 0x100000f7, +0xac22a708, 0x8fbf0018, 0x3e00008, 0x27bd0020, +0x27bdffd8, 0x803821, 0xafb1001c, 0xa08821, +0xafb00018, 0xc08021, 0x24020002, 0xafbf0024, +0xafb20020, 0x1222009b, 0xa7a00012, 0x2e220003, +0x10400005, 0x24020001, 0x1222000a, 0x0, +0x1000018f, 0x0, 0x24020004, 0x12220110, +0x24020008, 0x1222010f, 0x3c02ffec, 0x10000188, +0x0, 0x3c020002, 0x8c4284c8, 0x30420002, +0x14400004, 0x79140, 0x3c02fffb, 0x3442ffff, +0x2028024, 0x3c010002, 0x320821, 0xac30a71c, +0x3c024000, 0x2021024, 0x10400058, 0x1023c2, +0x30840030, 0x101382, 0x3042001c, 0x3c030002, +0x24638504, 0x431021, 0x824021, 0x3c020020, +0x2021024, 0x10400006, 0x24020100, 0x3c010002, +0x320821, 0xac22a720, 0x10000005, 0x3c020080, +0x3c010002, 0x320821, 0xac20a720, 0x3c020080, +0x2021024, 0x10400007, 0x71940, 0x3c020001, +0x3c010002, 0x230821, 0xac22a728, 0x10000005, +0x0, 0x71140, 0x3c010002, 0x220821, +0xac20a728, 0x95040000, 0x3c030002, 0x8c638660, +0x24020005, 0x10620010, 0xa7a40010, 0x32024000, +0x10400002, 0x34824000, 0xa7a20010, 0x24040001, +0x95020002, 0x24050004, 0x25060002, 0x34420001, +0xc004c3a, 0xa5020002, 0x24040001, 0x2821, +0xc004c3a, 0x27a60010, 0x3c020002, 0x8c4284cc, +0x14510003, 0x0, 0xc004343, 0x0, +0x8ee304b8, 0x24020003, 0x10620007, 0x24020001, +0x3c010002, 0xac2284d0, 0x3c010002, 0xac2284d8, +0x3c010002, 0xac228550, 0x32028000, 0x10400130, +0x0, 0xc004343, 0x0, 0x3c030002, +0x8c638660, 0x24020005, 0x10620129, 0x24020001, +0x3c010002, 0xac2284d0, 0x24020002, 0x3c010002, +0xac2284cc, 0x10000122, 0x0, 0x24040001, +0x24050004, 0x27b00012, 0xc004c3a, 0x2003021, +0x24040001, 0x2821, 0xc004c3a, 0x2003021, +0x3c020002, 0x521021, 0x8c42a714, 0x3c040002, +0x8c8484cc, 0x3c03bfff, 0x3463ffff, 0x3c010002, +0xac3184d8, 0x431024, 0x3c010002, 0x320821, +0xac22a714, 0x14910003, 0x0, 0xc004343, +0x0, 0x8ee304b8, 0x24020003, 0x10620104, +0x0, 0x3c010002, 0xac3184d0, 0x3c010002, +0xac3184d8, 0x3c010002, 0xac318550, 0x100000fc, 0x0, 0x3c022000, 0x2021024, 0x10400005, -0x24020001, 0x3c010001, 0xac226fdc, 0x10000004, -0x128940, 0x3c010001, 0xac206fdc, 0x128940, -0x3c010002, 0x310821, 0xac3090b8, 0x3c024000, -0x2021024, 0x14400014, 0x0, 0x3c020001, -0x8c426fdc, 0x10400006, 0x24040004, 0x24050001, -0xc004e0b, 0x24062000, 0x24020001, 0xaee204b8, -0x3c020002, 0x511021, 0x8c4290b0, 0x3c03bfff, +0x24020001, 0x3c010002, 0xac22863c, 0x10000004, +0x78940, 0x3c010002, 0xac20863c, 0x78940, +0x3c010002, 0x310821, 0xac30a718, 0x3c024000, +0x2021024, 0x14400015, 0x0, 0x3c020002, +0x8c42863c, 0x10400006, 0x24040004, 0x24050001, +0xc0053b9, 0x24062000, 0x24020001, 0xaee204b8, +0x3c020002, 0x511021, 0x8c42a710, 0x3c03bfff, 0x3463ffff, 0x431024, 0x3c010002, 0x310821, -0x100000d0, 0xac2290b0, 0x3c020001, 0x8c426fdc, -0x10400028, 0x3c0300a0, 0x2031024, 0x5443000d, -0x3c020020, 0x3c020001, 0x8c426fe0, 0x24030100, -0x3c010002, 0x310821, 0xac2390c4, 0x3c030001, -0x3c010002, 0x310821, 0xac2390cc, 0x10000015, -0x34420400, 0x2021024, 0x10400008, 0x24030100, -0x3c020001, 0x8c426fe0, 0x3c010002, 0x310821, -0xac2390c4, 0x1000000b, 0x34420800, 0x3c020080, -0x2021024, 0x1040002e, 0x3c030001, 0x3c020001, -0x8c426fe0, 0x3c010002, 0x310821, 0xac2390cc, -0x34420c00, 0x3c010001, 0xac226fe0, 0x10000025, -0x24040001, 0x3c020020, 0x2021024, 0x10400006, -0x24020100, 0x3c010002, 0x310821, 0xac2290c4, -0x10000005, 0x3c020080, 0x3c010002, 0x310821, -0xac2090c4, 0x3c020080, 0x2021024, 0x10400007, -0x121940, 0x3c020001, 0x3c010002, 0x230821, -0xac2290cc, 0x10000006, 0x24040001, 0x121140, -0x3c010002, 0x220821, 0xac2090cc, 0x24040001, -0x2821, 0x27b0001e, 0xc0045ac, 0x2003021, -0x24040001, 0x2821, 0xc0045ac, 0x2003021, -0x24040001, 0x24050001, 0x27b0001c, 0xc0045ac, -0x2003021, 0x24040001, 0x24050001, 0xc0045ac, -0x2003021, 0x10000077, 0x0, 0x3c02ffec, -0x3442ffff, 0x2028024, 0x3c020008, 0x2028025, -0x121140, 0x3c010002, 0x220821, 0xac3090b8, -0x3c022000, 0x2021024, 0x10400009, 0x0, -0x3c020001, 0x8c426f04, 0x14400005, 0x24020001, -0x3c010001, 0xac226fdc, 0x10000004, 0x3c024000, -0x3c010001, 0xac206fdc, 0x3c024000, 0x2021024, -0x1440001d, 0x24020e01, 0x3c030001, 0x8c636fdc, -0xaf820238, 0x3c010001, 0xac206e70, 0x10600005, -0x24022020, 0x3c010001, 0xac226fe0, 0x24020001, -0xaee204b8, 0x3c04bfff, 0x121940, 0x3c020002, -0x431021, 0x8c4290b0, 0x3c050001, 0x8ca56e58, -0x3484ffff, 0x441024, 0x3c010002, 0x230821, -0xac2290b0, 0x24020001, 0x10a20044, 0x0, -0x10000040, 0x0, 0x3c020001, 0x8c426fdc, -0x1040001c, 0x24022000, 0x3c010001, 0xac226fe0, -0x3c0300a0, 0x2031024, 0x14430005, 0x121140, -0x3402a000, 0x3c010001, 0x1000002d, 0xac226fe0, -0x3c030002, 0x621821, 0x8c6390b8, 0x3c020020, -0x621024, 0x10400004, 0x24022001, 0x3c010001, -0x10000023, 0xac226fe0, 0x3c020080, 0x621024, -0x1040001f, 0x3402a001, 0x3c010001, 0x1000001c, -0xac226fe0, 0x3c020020, 0x2021024, 0x10400007, -0x121940, 0x24020100, 0x3c010002, 0x230821, -0xac2290c4, 0x10000006, 0x3c020080, 0x121140, -0x3c010002, 0x220821, 0xac2090c4, 0x3c020080, -0x2021024, 0x10400006, 0x121940, 0x3c020001, -0x3c010002, 0x230821, 0x10000005, 0xac2290cc, -0x121140, 0x3c010002, 0x220821, 0xac2090cc, -0x3c030001, 0x8c636e58, 0x24020001, 0x10620003, -0x0, 0xc003dab, 0x0, 0x8fbf0030, -0x8fb3002c, 0x8fb20028, 0x8fb10024, 0x8fb00020, -0x3e00008, 0x27bd0038, 0x27bdffb0, 0xafb3003c, -0x9821, 0xafb50040, 0xa821, 0xafb10034, -0x8821, 0x24020002, 0xafbf0048, 0xafbe0044, -0xafb20038, 0xafb00030, 0xafa4002c, 0xa7a0001a, -0xa7a00018, 0xa7a00020, 0xa7a0001e, 0xa7a00022, -0x10a20130, 0xa7a0001c, 0x2ca20003, 0x10400005, -0x24020001, 0x10a2000a, 0x3c024000, 0x1000025d, -0x2201021, 0x24020004, 0x10a2020a, 0x24020008, -0x10a20208, 0x2201021, 0x10000256, 0x0, -0x8fa8002c, 0x88140, 0x3c030002, 0x701821, -0x8c6390bc, 0x621024, 0x14400009, 0x24040001, -0x3c027fff, 0x3442ffff, 0x628824, 0x3c010002, -0x300821, 0xac3190b4, 0x10000246, 0x2201021, -0x24050001, 0xc0045ac, 0x27a60018, 0x24040001, -0x24050001, 0xc0045ac, 0x27a60018, 0x97a20018, -0x30420004, 0x104000d9, 0x3c114000, 0x3c020001, -0x8c427000, 0x2443ffff, 0x2c620006, 0x104000d9, -0x31080, 0x3c010001, 0x220821, 0x8c226d28, -0x400008, 0x0, 0x24040001, 0x24050011, -0x27b0001a, 0xc0045ac, 0x2003021, 0x24040001, -0x24050011, 0xc0045ac, 0x2003021, 0x97a3001a, -0x30624000, 0x10400002, 0x3c150010, 0x3c150008, -0x30628000, 0x104000aa, 0x3c130001, 0x100000a8, -0x3c130002, 0x24040001, 0x24050014, 0x27b0001a, -0xc0045ac, 0x2003021, 0x24040001, 0x24050014, -0xc0045ac, 0x2003021, 0x97a3001a, 0x30621000, -0x10400002, 0x3c150010, 0x3c150008, 0x30620800, -0x10400097, 0x3c130001, 0x10000095, 0x3c130002, -0x24040001, 0x24050019, 0x27b0001c, 0xc0045ac, -0x2003021, 0x24040001, 0x24050019, 0xc0045ac, -0x2003021, 0x97a2001c, 0x30430700, 0x24020400, -0x10620027, 0x28620401, 0x1040000e, 0x24020200, -0x1062001f, 0x28620201, 0x10400005, 0x24020100, -0x5062001e, 0x3c130001, 0x1000001e, 0x24040001, -0x24020300, 0x50620019, 0x3c130002, 0x10000019, -0x24040001, 0x24020600, 0x1062000d, 0x28620601, -0x10400005, 0x24020500, 0x5062000b, 0x3c130002, -0x10000010, 0x24040001, 0x24020700, 0x1462000d, -0x24040001, 0x3c130004, 0x1000000a, 0x3c150008, -0x10000006, 0x3c130004, 0x10000005, 0x3c150008, -0x3c130001, 0x10000002, 0x3c150008, 0x3c150010, -0x24040001, 0x24050018, 0x27b0001e, 0xc0045ac, -0x2003021, 0x24040001, 0x24050018, 0xc0045ac, -0x2003021, 0x8fa8002c, 0x97a7001e, 0x81140, -0x3c060002, 0xc23021, 0x8cc690b4, 0x97a20022, -0x3c100001, 0x26106d1c, 0x2002021, 0xafa20010, -0x97a2001c, 0x3c05000c, 0x34a50303, 0xc002b37, -0xafa20014, 0x3c020004, 0x16620010, 0x3c020001, -0x8f840054, 0x24030001, 0x24020002, 0x3c010001, -0xac236e5c, 0x3c010001, 0xac226e58, 0x3c010001, -0xac236e64, 0x3c010001, 0xac236ee4, 0x3c010001, -0xac246ff0, 0x1000004f, 0x2b38825, 0x16620039, -0x3c028000, 0x3c020001, 0x8c426ee0, 0x1440001e, -0x24040018, 0x2021, 0x2821, 0xc004e0b, -0x34068000, 0x8f830054, 0x8f820054, 0x2b38825, -0x10000002, 0x24630032, 0x8f820054, 0x621023, -0x2c420033, 0x1440fffc, 0x0, 0x8f830054, -0x24020001, 0x3c010001, 0xac226ee0, 0x3c010001, -0xac226e5c, 0x3c010001, 0xac226e58, 0x3c010001, -0xac226e64, 0x3c010001, 0xac226ee4, 0x3c010001, -0x1000002c, 0xac236ff0, 0x2821, 0xc004e0b, +0xac22a710, 0x100000d4, 0x0, 0x3c020002, +0x8c42863c, 0x1040002e, 0x3c0300a0, 0x2031024, +0x14430010, 0x3c020020, 0x3c020002, 0x8c428640, +0x24030100, 0x3c010002, 0x310821, 0xac23a724, +0x3c030001, 0x3c010002, 0x310821, 0xac23a72c, +0x34420400, 0x3c010002, 0xac228640, 0x10000036, +0x0, 0x2021024, 0x1040000b, 0x24030100, +0x3c020002, 0x8c428640, 0x3c010002, 0x310821, +0xac23a724, 0x34420800, 0x3c010002, 0xac228640, +0x10000029, 0x0, 0x3c020080, 0x2021024, +0x10400025, 0x3c030001, 0x3c020002, 0x8c428640, +0x3c010002, 0x310821, 0xac23a72c, 0x34420c00, +0x3c010002, 0xac228640, 0x1000001b, 0x0, +0x3c020020, 0x2021024, 0x10400006, 0x24020100, +0x3c010002, 0x310821, 0xac22a724, 0x10000005, +0x3c020080, 0x3c010002, 0x310821, 0xac20a724, +0x3c020080, 0x2021024, 0x10400007, 0x71940, +0x3c020001, 0x3c010002, 0x230821, 0xac22a72c, +0x10000005, 0x0, 0x71140, 0x3c010002, +0x220821, 0xac20a72c, 0xc004343, 0x0, +0x8ee304b8, 0x24020003, 0x10620085, 0x24020001, +0x3c010002, 0xac2284d0, 0x3c010002, 0xac2284d8, +0x3c010002, 0xac228550, 0x1000007d, 0x0, +0x3c02ffec, 0x3442ffff, 0x2028024, 0x3c020008, +0x2028025, 0x71140, 0x3c010002, 0x220821, +0xac30a718, 0x3c022000, 0x2021024, 0x10400009, +0x0, 0x3c020002, 0x8c428568, 0x14400005, +0x24020001, 0x3c010002, 0xac22863c, 0x10000004, +0x3c024000, 0x3c010002, 0xac20863c, 0x3c024000, +0x2021024, 0x1440001d, 0x24020e01, 0x3c030002, +0x8c63863c, 0xaf820238, 0x3c010002, 0xac2084e4, +0x10600005, 0x24022020, 0x3c010002, 0xac228640, +0x24020001, 0xaee204b8, 0x3c04bfff, 0x71940, +0x3c020002, 0x431021, 0x8c42a710, 0x3c050002, +0x8ca584cc, 0x3484ffff, 0x441024, 0x3c010002, +0x230821, 0xac22a710, 0x24020001, 0x10a20048, +0x0, 0x10000044, 0x0, 0x3c020002, +0x8c42863c, 0x1040001f, 0x24022000, 0x3c010002, +0xac228640, 0x3c0300a0, 0x2031024, 0x14430006, +0x71140, 0x3402a000, 0x3c010002, 0xac228640, +0x10000030, 0x0, 0x3c030002, 0x621821, +0x8c63a718, 0x3c020020, 0x621024, 0x10400005, +0x24022001, 0x3c010002, 0xac228640, 0x10000025, +0x0, 0x3c020080, 0x621024, 0x10400021, +0x3402a001, 0x3c010002, 0xac228640, 0x1000001d, +0x0, 0x3c020020, 0x2021024, 0x10400007, +0x71940, 0x24020100, 0x3c010002, 0x230821, +0xac22a724, 0x10000006, 0x3c020080, 0x71140, +0x3c010002, 0x220821, 0xac20a724, 0x3c020080, +0x2021024, 0x10400007, 0x71940, 0x3c020001, +0x3c010002, 0x230821, 0xac22a72c, 0x10000005, +0x0, 0x71140, 0x3c010002, 0x220821, +0xac20a72c, 0x3c030002, 0x8c6384cc, 0x24020001, +0x10620003, 0x0, 0xc004343, 0x0, +0x8fbf0024, 0x8fb20020, 0x8fb1001c, 0x8fb00018, +0x3e00008, 0x27bd0028, 0x27bdffc8, 0xafb50030, +0x80a821, 0xafb20028, 0x9021, 0xafb3002c, +0x9821, 0xafb10024, 0x8821, 0x24020002, +0xafbf0034, 0xafb00020, 0xa7a0001a, 0xa7a00018, +0x10a20139, 0xa7a0001c, 0x2ca20003, 0x10400005, +0x24020001, 0x10a2000a, 0x158140, 0x10000232, +0x2201021, 0x24020004, 0x10a201e2, 0x24020008, +0x10a201e1, 0x152940, 0x1000022b, 0x2201021, +0x3c060002, 0xd03021, 0x8cc6a71c, 0x3c024000, +0xc21024, 0x14400009, 0x24040001, 0x3c027fff, +0x3442ffff, 0xc28824, 0x3c010002, 0x300821, +0xac31a714, 0x1000021c, 0x2201021, 0x24050001, +0xc004bf8, 0x27a60018, 0x24040001, 0x24050001, +0xc004bf8, 0x27a60018, 0x97a20018, 0x30420004, +0x104000e6, 0x3c114000, 0x3c020002, 0x8c428660, +0x2443ffff, 0x2c620007, 0x104000e6, 0x31080, +0x3c010002, 0x220821, 0x8c228210, 0x400008, +0x0, 0x24040001, 0x24050011, 0x27b0001a, +0xc004bf8, 0x2003021, 0x24040001, 0x24050011, +0xc004bf8, 0x2003021, 0x97a3001a, 0x30624000, +0x10400002, 0x3c130010, 0x3c130008, 0x3c120001, +0x10000011, 0x30628000, 0x24040001, 0x24050014, +0x27b0001a, 0xc004bf8, 0x2003021, 0x24040001, +0x24050014, 0xc004bf8, 0x2003021, 0x97a3001a, +0x30621000, 0x10400002, 0x3c130010, 0x3c130008, +0x3c120001, 0x30620800, 0x54400001, 0x3c120002, +0x3c028000, 0x2221025, 0x2531825, 0x100000b9, +0x438825, 0x24040001, 0x24050019, 0x27b0001c, +0xc004bf8, 0x2003021, 0x24040001, 0x24050019, +0xc004bf8, 0x2003021, 0x97a2001c, 0x30430700, +0x24020400, 0x10620027, 0x28620401, 0x1040000e, +0x24020200, 0x1062001f, 0x28620201, 0x10400005, +0x24020100, 0x5062001e, 0x3c120001, 0x1000001e, +0x3c020004, 0x24020300, 0x50620019, 0x3c120002, +0x10000019, 0x3c020004, 0x24020600, 0x1062000d, +0x28620601, 0x10400005, 0x24020500, 0x5062000b, +0x3c120002, 0x10000010, 0x3c020004, 0x24020700, +0x1462000d, 0x3c020004, 0x3c120004, 0x1000000a, +0x3c130008, 0x10000006, 0x3c120004, 0x10000005, +0x3c130008, 0x3c120001, 0x10000002, 0x3c130008, +0x3c130010, 0x3c020004, 0x16420010, 0x3c020001, +0x8f840054, 0x24030001, 0x24020002, 0x3c010002, +0xac2384d0, 0x3c010002, 0xac2284cc, 0x3c010002, +0xac2384d8, 0x3c010002, 0xac238550, 0x3c010002, +0xac248650, 0x10000073, 0x2728825, 0x16420050, +0x0, 0x3c020002, 0x8c42854c, 0x14400026, +0x2021, 0x2821, 0xc0053b9, 0x34068000, +0x8f830054, 0x8f820054, 0x2728825, 0x10000002, +0x24630032, 0x8f820054, 0x621023, 0x2c420033, +0x1440fffc, 0x3c05000c, 0x3c040002, 0x248481f0, +0x34a50540, 0x8f830054, 0x97a6001c, 0x24020001, +0x3c010002, 0xac22854c, 0x3c010002, 0xac2284d0, +0x3c010002, 0xac2284cc, 0x3c010002, 0xac2284d8, +0x3c010002, 0xac228550, 0xafb20010, 0xafb10014, +0x3c010002, 0xac238650, 0xc002d3b, 0x24070001, +0x10000048, 0x0, 0x3c030002, 0x8c63857c, +0x2c62000a, 0x14400027, 0x24620001, 0x24040018, +0x2821, 0x3c010002, 0xac20857c, 0xc0053b9, 0x24060404, 0x2021, 0x2405001e, 0x27a60018, -0x24020002, 0xc0045ee, 0xa7a20018, 0x2021, -0x2821, 0x27a60018, 0xc0045ee, 0xa7a00018, -0x24040018, 0x24050002, 0xc004e0b, 0x24060004, -0x3c028000, 0x2221025, 0x2b31825, 0x10000015, -0x438825, 0x2221025, 0x2751825, 0x438825, -0x2002021, 0x97a6001c, 0x3c070001, 0x8ce76e58, -0x3c05000c, 0x34a50326, 0xafb30010, 0xc002b37, +0x24020002, 0xc004c3a, 0xa7a20018, 0x2021, +0x2821, 0x27a60018, 0xc004c3a, 0xa7a00018, +0x24040018, 0x24050002, 0xc0053b9, 0x24060004, +0x3c028000, 0x2221025, 0x2721825, 0x438825, +0x3c040002, 0x248481f0, 0x97a6001c, 0x3c070002, +0x8ce784cc, 0x3c05000c, 0x10000017, 0x34a50530, +0x3c030002, 0x8c63857c, 0x2c62000a, 0x10400005, +0x24620001, 0x3c010002, 0xac22857c, 0x10000019, +0x2538825, 0x3c028000, 0x2221025, 0x2531825, +0x438825, 0x3c040002, 0x248481f0, 0x97a6001c, +0x3c070002, 0x8ce784cc, 0x3c05000c, 0x34a50326, +0x3c010002, 0xac20857c, 0xafb20010, 0xc002d3b, 0xafb10014, 0x10000007, 0x0, 0x3c110002, -0x2308821, 0x8e3190bc, 0x3c027fff, 0x3442ffff, -0x2228824, 0x3c020001, 0x8c426e68, 0x1040001e, -0x0, 0x3c020001, 0x8c426fdc, 0x10400002, -0x3c022000, 0x2228825, 0x8fa8002c, 0x81140, -0x3c010002, 0x220821, 0x8c2290c0, 0x10400003, -0x3c020020, 0x10000005, 0x2228825, 0x3c02ffdf, -0x3442ffff, 0x2228824, 0x8fa8002c, 0x81140, -0x3c010002, 0x220821, 0x8c2290c8, 0x10400003, -0x3c020080, 0x10000004, 0x2228825, 0x3c02ff7f, -0x3442ffff, 0x2228824, 0x8fa8002c, 0x81140, -0x3c010002, 0x220821, 0xac3190b4, 0x10000135, -0x2201021, 0x8fa8002c, 0x8f140, 0x3c030002, -0x7e1821, 0x8c6390b8, 0x3c024000, 0x621024, -0x14400009, 0x24040001, 0x3c027fff, 0x3442ffff, -0x628824, 0x3c010002, 0x3e0821, 0xac3190b0, -0x10000124, 0x2201021, 0x2821, 0xc0045ac, -0x27a60018, 0x24040001, 0x2821, 0xc0045ac, -0x27a60018, 0x24040001, 0x24050001, 0x27b20020, -0xc0045ac, 0x2403021, 0x24040001, 0x24050001, -0xc0045ac, 0x2403021, 0x24040001, 0x24050004, -0x27b1001e, 0xc0045ac, 0x2203021, 0x24040001, -0x24050004, 0xc0045ac, 0x2203021, 0x24040001, -0x24050005, 0x27b00022, 0xc0045ac, 0x2003021, -0x24040001, 0x24050005, 0xc0045ac, 0x2003021, -0x24040001, 0x24050010, 0xc0045ac, 0x27a60018, -0x24040001, 0x24050010, 0xc0045ac, 0x27a60018, -0x24040001, 0x2405000a, 0xc0045ac, 0x2403021, -0x24040001, 0x2405000a, 0xc0045ac, 0x2403021, -0x24040001, 0x24050018, 0xc0045ac, 0x2203021, -0x24040001, 0x24050018, 0xc0045ac, 0x2203021, -0x24040001, 0x24050001, 0xc0045ac, 0x27a60018, -0x24040001, 0x24050001, 0xc0045ac, 0x27a60018, -0x97a20018, 0x30420004, 0x10400066, 0x3c114000, -0x3c030001, 0x8c636ff4, 0x24020005, 0x14620067, -0x24040001, 0x24050019, 0x27b0001c, 0xc0045ac, -0x2003021, 0x24040001, 0x24050019, 0xc0045ac, -0x2003021, 0x97a2001c, 0x30430700, 0x24020400, -0x10620027, 0x28620401, 0x1040000e, 0x24020200, -0x1062001f, 0x28620201, 0x10400005, 0x24020100, -0x5062001e, 0x3c130001, 0x1000001e, 0x3c020004, -0x24020300, 0x50620019, 0x3c130002, 0x10000019, -0x3c020004, 0x24020600, 0x1062000d, 0x28620601, -0x10400005, 0x24020500, 0x5062000b, 0x3c130002, -0x10000010, 0x3c020004, 0x24020700, 0x1462000d, -0x3c020004, 0x3c130004, 0x1000000a, 0x3c150008, -0x10000006, 0x3c130004, 0x10000005, 0x3c150008, -0x3c130001, 0x10000002, 0x3c150008, 0x3c150010, -0x3c020004, 0x12620017, 0x3c028000, 0x8f820054, -0x24100001, 0x3c010001, 0xac306e5c, 0x3c010001, -0xac306e58, 0x3c010001, 0xac306e64, 0x3c010001, -0xac306ee4, 0x3c010001, 0xac226ff0, 0x3c020001, -0x16620022, 0x2758825, 0x2021, 0x2821, -0xc004e0b, 0x34068000, 0x3c010001, 0x1000001b, -0xac306ee0, 0x2221025, 0x2b31825, 0x438825, -0x97a6001c, 0x3c020001, 0x8c426fdc, 0x3c070001, -0x8ce76e58, 0x3c040001, 0x24846d1c, 0xafa20010, -0x97a2001e, 0x3c05000c, 0x34a50323, 0x3c010001, -0xac206ee0, 0xc002b37, 0xafa20014, 0x10000007, -0x0, 0x3c110002, 0x23e8821, 0x8e3190b0, -0x3c027fff, 0x3442ffff, 0x2228824, 0x3c020001, -0x8c426e68, 0x10400069, 0x0, 0x3c020001, -0x8c426fdc, 0x10400002, 0x3c022000, 0x2228825, -0x8fa8002c, 0x81140, 0x3c010002, 0x220821, -0x8c2290c4, 0x10400003, 0x3c020020, 0x10000005, -0x2228825, 0x3c02ffdf, 0x3442ffff, 0x2228824, -0x8fa8002c, 0x81140, 0x3c010002, 0x220821, -0x8c2290cc, 0x10400003, 0x3c020080, 0x1000004f, -0x2228825, 0x3c02ff7f, 0x3442ffff, 0x1000004b, -0x2228824, 0x8fa8002c, 0x82940, 0x3c030002, -0x651821, 0x8c6390b8, 0x3c024000, 0x621024, -0x14400008, 0x3c027fff, 0x3442ffff, 0x628824, -0x3c010002, 0x250821, 0xac3190b0, 0x10000041, -0x2201021, 0x3c020001, 0x8c426e68, 0x10400034, -0x3c11c00c, 0x3c020001, 0x8c426f04, 0x3c04c00c, -0x34842000, 0x3c030001, 0x8c636fdc, 0x2102b, -0x21023, 0x441024, 0x10600003, 0x518825, -0x3c022000, 0x2228825, 0x3c020002, 0x451021, -0x8c4290c4, 0x10400003, 0x3c020020, 0x10000004, -0x2228825, 0x3c02ffdf, 0x3442ffff, 0x2228824, -0x8fa8002c, 0x81140, 0x3c010002, 0x220821, -0x8c2290cc, 0x10400003, 0x3c020080, 0x10000004, +0x2308821, 0x8e31a71c, 0x3c027fff, 0x3442ffff, +0x2228824, 0x3c020002, 0x8c4284dc, 0x1040001d, +0x151140, 0x3c020002, 0x8c42863c, 0x10400002, +0x3c022000, 0x2228825, 0x151140, 0x3c010002, +0x220821, 0x8c22a720, 0x10400003, 0x3c020020, +0x10000004, 0x2228825, 0x3c02ffdf, 0x3442ffff, +0x2228824, 0x151140, 0x3c010002, 0x220821, +0x8c22a728, 0x10400003, 0x3c020080, 0x10000004, 0x2228825, 0x3c02ff7f, 0x3442ffff, 0x2228824, -0x3c020001, 0x8c426ef0, 0x10400002, 0x3c020800, -0x2228825, 0x3c020001, 0x8c426ef4, 0x10400002, -0x3c020400, 0x2228825, 0x3c020001, 0x8c426ef8, -0x10400006, 0x3c020100, 0x10000004, 0x2228825, -0x3c027fff, 0x3442ffff, 0x628824, 0x8fa8002c, -0x81140, 0x3c010002, 0x220821, 0xac3190b0, -0x2201021, 0x8fbf0048, 0x8fbe0044, 0x8fb50040, -0x8fb3003c, 0x8fb20038, 0x8fb10034, 0x8fb00030, -0x3e00008, 0x27bd0050, 0x27bdffd0, 0xafb20028, +0x151140, 0x3c010002, 0x220821, 0xac31a714, +0x10000101, 0x2201021, 0x158140, 0x3c060002, +0xd03021, 0x8cc6a718, 0x3c024000, 0xc21024, +0x14400009, 0x24040001, 0x3c027fff, 0x3442ffff, +0xc28824, 0x3c010002, 0x300821, 0xac31a710, +0x100000f1, 0x2201021, 0x24050001, 0xc004bf8, +0x27a60018, 0x24040001, 0x24050001, 0xc004bf8, +0x27a60018, 0x97a20018, 0x30420004, 0x10400073, +0x3c114000, 0x3c030002, 0x8c638654, 0x24020005, +0x14620074, 0x24040001, 0x24050019, 0x27b0001c, +0xc004bf8, 0x2003021, 0x24040001, 0x24050019, +0xc004bf8, 0x2003021, 0x97a2001c, 0x30430700, +0x24020400, 0x10620027, 0x28620401, 0x1040000e, +0x24020200, 0x1062001f, 0x28620201, 0x10400005, +0x24020100, 0x5062001e, 0x3c120001, 0x1000001e, +0x3c020004, 0x24020300, 0x50620019, 0x3c120002, +0x10000019, 0x3c020004, 0x24020600, 0x1062000d, +0x28620601, 0x10400005, 0x24020500, 0x5062000b, +0x3c120002, 0x10000010, 0x3c020004, 0x24020700, +0x1462000d, 0x3c020004, 0x3c120004, 0x1000000a, +0x3c130008, 0x10000006, 0x3c120004, 0x10000005, +0x3c130008, 0x3c120001, 0x10000002, 0x3c130008, +0x3c130010, 0x3c020004, 0x12420021, 0x3c05000c, +0x2538825, 0x3c040002, 0x248481f8, 0x34a50328, +0x8f820054, 0x97a6001c, 0x24100001, 0x3c010002, +0xac3084d0, 0x3c010002, 0xac3084cc, 0x3c010002, +0xac3084d8, 0x3c010002, 0xac308550, 0xafb20010, +0xafb10014, 0x3c010002, 0xac228650, 0xc002d3b, +0x24070001, 0x2021, 0x2821, 0xc0053b9, +0x34068000, 0x3c020001, 0x16420022, 0x0, +0x3c010002, 0xac30854c, 0x1000001e, 0x0, +0x3c028000, 0x2221025, 0x2721825, 0x438825, +0x151140, 0x3c070002, 0xe23821, 0x8ce7a710, +0x3c010002, 0x220821, 0x8c22a718, 0x3c040002, +0x24848204, 0xafa20010, 0x97a2001c, 0x34a50300, +0x2203021, 0x3c010002, 0xac20854c, 0xc002d3b, +0xafa20014, 0x10000007, 0x0, 0x3c110002, +0x2308821, 0x8e31a710, 0x3c027fff, 0x3442ffff, +0x2228824, 0x3c020002, 0x8c4284dc, 0x10400066, +0x151140, 0x3c020002, 0x8c42863c, 0x10400002, +0x3c022000, 0x2228825, 0x151140, 0x3c010002, +0x220821, 0x8c22a724, 0x10400003, 0x3c020020, +0x10000004, 0x2228825, 0x3c02ffdf, 0x3442ffff, +0x2228824, 0x151140, 0x3c010002, 0x220821, +0x8c22a72c, 0x10400003, 0x3c020080, 0x1000004d, +0x2228825, 0x3c02ff7f, 0x3442ffff, 0x10000049, +0x2228824, 0x152940, 0x3c060002, 0xc53021, +0x8cc6a718, 0x3c024000, 0xc21024, 0x14400008, +0x3c027fff, 0x3442ffff, 0xc28824, 0x3c010002, +0x250821, 0xac31a710, 0x1000003f, 0x2201021, +0x3c020002, 0x8c4284dc, 0x10400033, 0x3c11c00c, +0x3c020002, 0x8c428568, 0x3c04c00c, 0x34842000, +0x3c030002, 0x8c63863c, 0x2102b, 0x21023, +0x441024, 0x10600003, 0x518825, 0x3c022000, +0x2228825, 0x3c020002, 0x451021, 0x8c42a724, +0x10400003, 0x3c020020, 0x10000004, 0x2228825, +0x3c02ffdf, 0x3442ffff, 0x2228824, 0x151140, +0x3c010002, 0x220821, 0x8c22a72c, 0x10400003, +0x3c020080, 0x10000004, 0x2228825, 0x3c02ff7f, +0x3442ffff, 0x2228824, 0x3c020002, 0x8c428554, +0x10400002, 0x3c020800, 0x2228825, 0x3c020002, +0x8c428558, 0x10400002, 0x3c020400, 0x2228825, +0x3c020002, 0x8c42855c, 0x10400006, 0x3c020100, +0x10000004, 0x2228825, 0x3c027fff, 0x3442ffff, +0xc28824, 0x151140, 0x3c010002, 0x220821, +0xac31a710, 0x2201021, 0x8fbf0034, 0x8fb50030, +0x8fb3002c, 0x8fb20028, 0x8fb10024, 0x8fb00020, +0x3e00008, 0x27bd0038, 0x27bdffd0, 0xafb20028, 0x809021, 0xafbf002c, 0xafb10024, 0xafb00020, -0x8f840200, 0x3c100001, 0x8e106e58, 0x8f860220, -0x24020002, 0x1202005c, 0x2e020003, 0x10400005, -0x24020001, 0x1202000a, 0x121940, 0x1000010c, -0x0, 0x24020004, 0x120200bf, 0x24020008, -0x120200be, 0x128940, 0x10000105, 0x0, -0x3c050002, 0xa32821, 0x8ca590bc, 0x3c100002, -0x2038021, 0x8e1090b4, 0x3c024000, 0xa21024, +0x8f840200, 0x3c100002, 0x8e1084cc, 0x8f860220, +0x24020002, 0x1202005e, 0x2e020003, 0x10400005, +0x24020001, 0x1202000a, 0x121940, 0x10000114, +0x0, 0x24020004, 0x120200c6, 0x24020008, +0x120200c5, 0x128940, 0x1000010d, 0x0, +0x3c050002, 0xa32821, 0x8ca5a71c, 0x3c100002, +0x2038021, 0x8e10a714, 0x3c024000, 0xa21024, 0x10400038, 0x3c020008, 0x2021024, 0x10400020, -0x34840002, 0x3c020002, 0x431021, 0x8c4290c0, +0x34840002, 0x3c020002, 0x431021, 0x8c42a720, 0x10400005, 0x34840020, 0x34840100, 0x3c020020, 0x10000006, 0x2028025, 0x2402feff, 0x822024, 0x3c02ffdf, 0x3442ffff, 0x2028024, 0x121140, -0x3c010002, 0x220821, 0x8c2290c8, 0x10400005, +0x3c010002, 0x220821, 0x8c22a728, 0x10400005, 0x3c020001, 0xc23025, 0x3c020080, 0x10000016, 0x2028025, 0x3c02fffe, 0x3442ffff, 0xc23024, 0x3c02ff7f, 0x3442ffff, 0x1000000f, 0x2028024, 0x2402fedf, 0x822024, 0x3c02fffe, 0x3442ffff, 0xc23024, 0x3c02ff5f, 0x3442ffff, 0x2028024, -0x3c010002, 0x230821, 0xac2090c0, 0x3c010002, -0x230821, 0xac2090c8, 0xaf840200, 0xaf860220, -0x8f820220, 0x34420002, 0xaf820220, 0x1000000a, +0x3c010002, 0x230821, 0xac20a720, 0x3c010002, +0x230821, 0xac20a728, 0xaf840200, 0xaf860220, +0x8f820220, 0x34420002, 0xaf820220, 0x1000000b, 0x121140, 0x3c02bfff, 0x3442ffff, 0x8f830200, -0x2028024, 0x2402fffd, 0x621824, 0xc003dab, -0xaf830200, 0x121140, 0x3c010002, 0x220821, -0x100000b7, 0xac3090b4, 0x3c020001, 0x8c426fdc, -0x10400069, 0x24050004, 0x24040001, 0xc0045ac, -0x27a60018, 0x24040001, 0x24050005, 0xc0045ac, -0x27a6001a, 0x97a30018, 0x97a2001a, 0x3c040001, -0x24846f08, 0x30630c00, 0x31a82, 0x30420c00, -0x21282, 0xa7a2001a, 0x21080, 0x441021, -0x431021, 0xa7a30018, 0x90480000, 0x24020001, -0x3103ffff, 0x10620029, 0x28620002, 0x10400005, -0x0, 0x10600009, 0x0, 0x1000003d, -0x0, 0x10700013, 0x24020003, 0x1062002c, -0x0, 0x10000037, 0x0, 0x8f820200, -0x2403feff, 0x431024, 0xaf820200, 0x8f820220, +0x2028024, 0x2402fffd, 0x621824, 0xaf830200, +0xc004343, 0x0, 0x121140, 0x3c010002, +0x220821, 0xac30a714, 0x100000bd, 0x0, +0x3c020002, 0x8c42863c, 0x104000b9, 0x24040001, +0x24050004, 0xc004bf8, 0x27a60018, 0x24040001, +0x24050005, 0xc004bf8, 0x27a6001a, 0x97a30018, +0x97a2001a, 0x3c040002, 0x2484856c, 0x30630c00, +0x31a82, 0x30420c00, 0x21282, 0xa7a2001a, +0x21080, 0x441021, 0x431021, 0xa7a30018, +0x90480000, 0x24020001, 0x3103ffff, 0x1062002b, +0x28620002, 0x10400005, 0x0, 0x10600009, +0x0, 0x10000041, 0x0, 0x10700014, +0x24020003, 0x1062002f, 0x0, 0x1000003b, +0x0, 0x8f820200, 0x2403feff, 0x431024, +0xaf820200, 0x8f820220, 0x3c03fffe, 0x3463ffff, +0x431024, 0xaf820220, 0x3c010002, 0xac20a724, +0x3c010002, 0xac20a72c, 0x10000035, 0x0, +0x8f820200, 0x34420100, 0xaf820200, 0x8f820220, 0x3c03fffe, 0x3463ffff, 0x431024, 0xaf820220, -0x3c010002, 0xac2090c4, 0x3c010002, 0x10000032, -0xac2090cc, 0x8f820200, 0x34420100, 0xaf820200, -0x8f820220, 0x3c03fffe, 0x3463ffff, 0x431024, -0xaf820220, 0x24020100, 0x3c010002, 0xac2290c4, -0x3c010002, 0x10000024, 0xac2090cc, 0x8f820200, +0x24020100, 0x3c010002, 0xac22a724, 0x3c010002, +0xac20a72c, 0x10000026, 0x0, 0x8f820200, 0x2403feff, 0x431024, 0xaf820200, 0x8f820220, 0x3c030001, 0x431025, 0xaf820220, 0x3c010002, -0xac2090c4, 0x3c010002, 0x10000017, 0xac2390cc, -0x8f820200, 0x34420100, 0xaf820200, 0x8f820220, -0x3c030001, 0x431025, 0xaf820220, 0x24020100, -0x3c010002, 0xac2290c4, 0x3c010002, 0x1000000a, -0xac2390cc, 0x3c040001, 0x24846d40, 0x97a6001a, -0x97a70018, 0x3c050001, 0x34a5ffff, 0xafa80010, -0xc002b37, 0xafa00014, 0x8f820200, 0x34420002, -0x1000004b, 0xaf820200, 0x128940, 0x3c050002, -0xb12821, 0x8ca590b8, 0x3c100002, 0x2118021, -0x8e1090b0, 0x3c024000, 0xa21024, 0x14400010, -0x0, 0x3c020001, 0x8c426fdc, 0x14400005, -0x3c02bfff, 0x8f820200, 0x34420002, 0xaf820200, -0x3c02bfff, 0x3442ffff, 0xc003dab, 0x2028024, -0x3c010002, 0x310821, 0x10000031, 0xac3090b0, -0x3c020001, 0x8c426fdc, 0x10400005, 0x3c020020, -0x3c020001, 0x8c426f04, 0x10400025, 0x3c020020, +0xac20a724, 0x3c010002, 0xac23a72c, 0x10000018, +0x0, 0x8f820200, 0x34420100, 0xaf820200, +0x8f820220, 0x3c030001, 0x431025, 0xaf820220, +0x24020100, 0x3c010002, 0xac22a724, 0x3c010002, +0xac23a72c, 0x1000000a, 0x0, 0x3c040002, +0x2484822c, 0x97a6001a, 0x97a70018, 0x3c050001, +0x34a5ffff, 0xafa80010, 0xc002d3b, 0xafa00014, +0x8f820200, 0x34420002, 0xaf820200, 0x1000004c, +0x0, 0x128940, 0x3c050002, 0xb12821, +0x8ca5a718, 0x3c100002, 0x2118021, 0x8e10a710, +0x3c024000, 0xa21024, 0x14400011, 0x0, +0x3c020002, 0x8c42863c, 0x14400005, 0x3c02bfff, +0x8f820200, 0x34420002, 0xaf820200, 0x3c02bfff, +0x3442ffff, 0xc004343, 0x2028024, 0x3c010002, +0x310821, 0xac30a710, 0x10000031, 0x0, +0x3c020002, 0x8c42863c, 0x10400005, 0x3c020020, +0x3c020002, 0x8c428568, 0x10400025, 0x3c020020, 0xa21024, 0x10400007, 0x34840020, 0x24020100, -0x3c010002, 0x310821, 0xac2290c4, 0x10000006, -0x34840100, 0x3c010002, 0x310821, 0xac2090c4, +0x3c010002, 0x310821, 0xac22a724, 0x10000006, +0x34840100, 0x3c010002, 0x310821, 0xac20a724, 0x2402feff, 0x822024, 0x3c020080, 0xa21024, 0x10400007, 0x121940, 0x3c020001, 0x3c010002, -0x230821, 0xac2290cc, 0x10000008, 0xc23025, -0x121140, 0x3c010002, 0x220821, 0xac2090cc, +0x230821, 0xac22a72c, 0x10000008, 0xc23025, +0x121140, 0x3c010002, 0x220821, 0xac20a72c, 0x3c02fffe, 0x3442ffff, 0xc23024, 0xaf840200, 0xaf860220, 0x8f820220, 0x34420002, 0xaf820220, -0x121140, 0x3c010002, 0x220821, 0xac3090b0, +0x121140, 0x3c010002, 0x220821, 0xac30a710, 0x8fbf002c, 0x8fb20028, 0x8fb10024, 0x8fb00020, -0x3e00008, 0x27bd0030, 0x0, 0x1821, -0x308400ff, 0x2405ffdf, 0x2406ffbf, 0x641007, -0x30420001, 0x10400004, 0x0, 0x8f820044, -0x10000003, 0x34420040, 0x8f820044, 0x461024, -0xaf820044, 0x8f820044, 0x34420020, 0xaf820044, -0x8f820044, 0x451024, 0xaf820044, 0x24630001, -0x28620008, 0x5440ffee, 0x641007, 0x3e00008, -0x0, 0x2c820008, 0x1040001b, 0x0, -0x2405ffdf, 0x2406ffbf, 0x41880, 0x3c020001, -0x24426f20, 0x621821, 0x24640004, 0x90620000, +0x3e00008, 0x27bd0030, 0x1821, 0x308400ff, +0x2405ffdf, 0x2406ffbf, 0x641007, 0x30420001, 0x10400004, 0x0, 0x8f820044, 0x10000003, 0x34420040, 0x8f820044, 0x461024, 0xaf820044, 0x8f820044, 0x34420020, 0xaf820044, 0x8f820044, -0x451024, 0xaf820044, 0x24630001, 0x64102b, -0x1440ffee, 0x0, 0x3e00008, 0x0, -0x0, 0x0, 0x0, 0x8f8400c4, -0x8f8600e0, 0x8f8700e4, 0x2402fff8, 0xc22824, -0x10e5001a, 0x27623ff8, 0x14e20002, 0x24e80008, -0x27683000, 0x55050004, 0x8d0a0000, 0x30c20004, -0x14400012, 0x805021, 0x8ce90000, 0x8f42013c, -0x1494823, 0x49182b, 0x94eb0006, 0x10600002, -0x25630050, 0x494821, 0x123182b, 0x50400003, -0x8f4201fc, 0x3e00008, 0xe01021, 0xaf8800e8, -0x24420001, 0xaf4201fc, 0xaf8800e4, 0x3e00008, -0x1021, 0x3e00008, 0x0, 0x8f8300e4, -0x27623ff8, 0x10620004, 0x24620008, 0xaf8200e8, -0x3e00008, 0xaf8200e4, 0x27623000, 0xaf8200e8, -0x3e00008, 0xaf8200e4, 0x3e00008, 0x0, -0x0, 0x0, 0x0, 0x8f880120, -0x27624fe0, 0x8f830128, 0x15020002, 0x25090020, -0x27694800, 0x11230012, 0x8fa20010, 0xad040000, -0xad050004, 0xad060008, 0xa507000e, 0x8fa30014, -0xad020018, 0x8fa20018, 0xad03001c, 0x25030016, -0xad020010, 0xad030014, 0xaf890120, 0x8f4300fc, -0x24020001, 0x2463ffff, 0x3e00008, 0xaf4300fc, -0x8f430324, 0x1021, 0x24630001, 0x3e00008, -0xaf430324, 0x3e00008, 0x0, 0x8f880100, -0x276247e0, 0x8f830108, 0x15020002, 0x25090020, -0x27694000, 0x1123000f, 0x8fa20010, 0xad040000, -0xad050004, 0xad060008, 0xa507000e, 0x8fa30014, -0xad020018, 0x8fa20018, 0xad03001c, 0x25030016, -0xad020010, 0xad030014, 0xaf890100, 0x3e00008, -0x24020001, 0x8f430328, 0x1021, 0x24630001, -0x3e00008, 0xaf430328, 0x3e00008, 0x0, -0x0, 0x0, 0x0, 0x0 }; +0x451024, 0xaf820044, 0x24630001, 0x28620008, +0x5440ffee, 0x641007, 0x3e00008, 0x0, +0x2c820008, 0x1040001b, 0x0, 0x2405ffdf, +0x2406ffbf, 0x41880, 0x3c020002, 0x24428580, +0x621821, 0x24640004, 0x90620000, 0x10400004, +0x0, 0x8f820044, 0x10000003, 0x34420040, +0x8f820044, 0x461024, 0xaf820044, 0x8f820044, +0x34420020, 0xaf820044, 0x8f820044, 0x451024, +0xaf820044, 0x24630001, 0x64102b, 0x1440ffee, +0x0, 0x3e00008, 0x0, 0x0 }; static u_int32_t tigon2FwRodata[] = { 0x24486561, 0x6465723a, 0x202f7072, 0x6f6a6563, 0x74732f72, @@ -4590,14 +4915,14 @@ 0x0, 0x4d516576, 0x74460000, 0x4d516576, 0x505f4600, 0x5173436f, 0x6e495f46, 0x0, 0x5173436f, 0x6e734600, 0x51725072, 0x6f644600, -0x6261644d, 0x656d537a, 0x0, 0x68775665, -0x72000000, 0x62616448, 0x77566572, 0x0, -0x2a2a4441, 0x574e5f41, 0x0, 0x74785278, -0x4266537a, 0x0, 0x62664174, 0x6e4d726b, -0x0, 0x7265645a, 0x6f6e6531, 0x0, -0x70636943, 0x6f6e6600, 0x67656e43, 0x6f6e6600, -0x2a646d61, 0x5244666c, 0x0, 0x2a50414e, +0x6261644d, 0x656d537a, 0x0, 0x2a50414e, 0x49432a00, 0x66776d61, 0x696e2e63, 0x0, +0x68775665, 0x72000000, 0x62616448, 0x77566572, +0x0, 0x2a2a4441, 0x574e5f41, 0x0, +0x74785278, 0x4266537a, 0x0, 0x62664174, +0x6e4d726b, 0x0, 0x7265645a, 0x6f6e6531, +0x0, 0x70636943, 0x6f6e6600, 0x67656e43, +0x6f6e6600, 0x2a646d61, 0x5244666c, 0x0, 0x72636246, 0x6c616773, 0x0, 0x62616452, 0x78526362, 0x0, 0x676c6f62, 0x466c6773, 0x0, 0x2b5f6469, 0x73705f6c, 0x6f6f7000, @@ -4664,114 +4989,106 @@ 0x51657674, 0x505f4600, 0x4d657674, 0x526e6746, 0x0, 0x4d516576, 0x74460000, 0x4d516576, 0x505f4600, 0x5173436f, 0x6e495f46, 0x0, -0x5173436f, 0x6e734600, 0x51725072, 0x6f644600, -0x542d446d, 0x61526432, 0x0, 0x542d446d, -0x61526431, 0x0, 0x542d446d, 0x61526442, -0x0, 0x542d446d, 0x61577232, 0x0, -0x542d446d, 0x61577231, 0x0, 0x542d446d, -0x61577242, 0x0, 0x0, 0x24486561, -0x6465723a, 0x202f7072, 0x6f6a6563, 0x74732f72, -0x63732f73, 0x772f6765, 0x2f2e2f6e, 0x69632f66, -0x77322f63, 0x6f6d6d6f, 0x6e2f636f, 0x6d6d616e, -0x642e632c, 0x7620312e, 0x312e322e, 0x32382031, -0x3939392f, 0x30312f32, 0x30203139, 0x3a34393a, -0x34392073, 0x6875616e, 0x67204578, 0x70202400, -0x65767452, 0x6e674600, 0x51657674, 0x46000000, -0x51657674, 0x505f4600, 0x4d657674, 0x526e6746, -0x0, 0x4d516576, 0x74460000, 0x4d516576, -0x505f4600, 0x5173436f, 0x6e495f46, 0x0, -0x5173436f, 0x6e734600, 0x51725072, 0x6f644600, -0x3f48636d, 0x644d6278, 0x0, 0x3f636d64, -0x48737453, 0x0, 0x3f636d64, 0x4d634d64, -0x0, 0x3f636d64, 0x50726f6d, 0x0, -0x3f636d64, 0x4c696e6b, 0x0, 0x3f636d64, -0x45727200, 0x86ac, 0x8e5c, 0x8e5c, -0x8de4, 0x8b78, 0x8e30, 0x8e5c, -0x8790, 0x8800, 0x8990, 0x8a68, -0x8a34, 0x8e5c, 0x8870, 0x8b24, -0x8e5c, 0x8b34, 0x87b4, 0x8824, -0x0, 0x0, 0x0, 0x24486561, -0x6465723a, 0x202f7072, 0x6f6a6563, 0x74732f72, -0x63732f73, 0x772f6765, 0x2f2e2f6e, 0x69632f66, -0x77322f63, 0x6f6d6d6f, 0x6e2f6d63, 0x6173742e, -0x632c7620, 0x312e312e, 0x322e3820, 0x31393938, -0x2f31322f, 0x30382030, 0x323a3336, 0x3a333620, -0x73687561, 0x6e672045, 0x78702024, 0x0, -0x65767452, 0x6e674600, 0x51657674, 0x46000000, -0x51657674, 0x505f4600, 0x4d657674, 0x526e6746, -0x0, 0x4d516576, 0x74460000, 0x4d516576, -0x505f4600, 0x5173436f, 0x6e495f46, 0x0, 0x5173436f, 0x6e734600, 0x51725072, 0x6f644600, -0x6164644d, 0x63447570, 0x0, 0x6164644d, -0x6346756c, 0x0, 0x64656c4d, 0x634e6f45, -0x0, 0x0, 0x0, 0x24486561, -0x6465723a, 0x202f7072, 0x6f6a6563, 0x74732f72, -0x63732f73, 0x772f6765, 0x2f2e2f6e, 0x69632f66, -0x77322f63, 0x6f6d6d6f, 0x6e2f646d, 0x612e632c, -0x7620312e, 0x312e322e, 0x32342031, 0x3939382f, -0x31322f32, 0x31203030, 0x3a33333a, 0x30392073, -0x6875616e, 0x67204578, 0x70202400, 0x65767452, +0x2a50414e, 0x49432a00, 0x6d61632e, 0x68000000, +0x74696d65, 0x722e6300, 0x542d446d, 0x61526432, +0x0, 0x542d446d, 0x61526431, 0x0, +0x542d446d, 0x61526442, 0x0, 0x542d446d, +0x61577232, 0x0, 0x542d446d, 0x61577231, +0x0, 0x542d446d, 0x61577242, 0x0, +0x0, 0x24486561, 0x6465723a, 0x202f7072, +0x6f6a6563, 0x74732f72, 0x63732f73, 0x772f6765, +0x2f2e2f6e, 0x69632f66, 0x77322f63, 0x6f6d6d6f, +0x6e2f636f, 0x6d6d616e, 0x642e632c, 0x7620312e, +0x312e322e, 0x32382031, 0x3939392f, 0x30312f32, +0x30203139, 0x3a34393a, 0x34392073, 0x6875616e, +0x67204578, 0x70202400, 0x65767452, 0x6e674600, +0x51657674, 0x46000000, 0x51657674, 0x505f4600, +0x4d657674, 0x526e6746, 0x0, 0x4d516576, +0x74460000, 0x4d516576, 0x505f4600, 0x5173436f, +0x6e495f46, 0x0, 0x5173436f, 0x6e734600, +0x51725072, 0x6f644600, 0x3f48636d, 0x644d6278, +0x0, 0x3f636d64, 0x48737453, 0x0, +0x3f636d64, 0x4d634d64, 0x0, 0x3f636d64, +0x50726f6d, 0x0, 0x3f636d64, 0x4c696e6b, +0x0, 0x3f636d64, 0x45727200, 0x8b08, +0x92e4, 0x92e4, 0x9264, 0x8ff4, +0x92b8, 0x92e4, 0x8bf4, 0x8c64, +0x8df8, 0x8ee0, 0x8ea8, 0x92e4, +0x8cd4, 0x8fa0, 0x92e4, 0x8fb0, +0x8c18, 0x8c88, 0x24486561, 0x6465723a, +0x202f7072, 0x6f6a6563, 0x74732f72, 0x63732f73, +0x772f6765, 0x2f2e2f6e, 0x69632f66, 0x77322f63, +0x6f6d6d6f, 0x6e2f6d63, 0x6173742e, 0x632c7620, +0x312e312e, 0x322e3820, 0x31393938, 0x2f31322f, +0x30382030, 0x323a3336, 0x3a333620, 0x73687561, +0x6e672045, 0x78702024, 0x0, 0x65767452, 0x6e674600, 0x51657674, 0x46000000, 0x51657674, 0x505f4600, 0x4d657674, 0x526e6746, 0x0, 0x4d516576, 0x74460000, 0x4d516576, 0x505f4600, 0x5173436f, 0x6e495f46, 0x0, 0x5173436f, -0x6e734600, 0x51725072, 0x6f644600, 0x7377446d, -0x614f6666, 0x0, 0x31446d61, 0x4f6e0000, -0x7377446d, 0x614f6e00, 0x2372446d, 0x6141544e, -0x0, 0x72446d61, 0x41544e30, 0x0, -0x72446d61, 0x41544e31, 0x0, 0x72446d61, -0x34476200, 0x2a50414e, 0x49432a00, 0x646d612e, -0x63000000, 0x2377446d, 0x6141544e, 0x0, -0x77446d61, 0x41544e30, 0x0, 0x77446d61, -0x41544e31, 0x0, 0x77446d61, 0x34476200, -0x0, 0x0, 0x0, 0x24486561, -0x6465723a, 0x202f7072, 0x6f6a6563, 0x74732f72, -0x63732f73, 0x772f6765, 0x2f2e2f6e, 0x69632f66, -0x77322f63, 0x6f6d6d6f, 0x6e2f7472, 0x6163652e, -0x632c7620, 0x312e312e, 0x322e3520, 0x31393938, -0x2f30392f, 0x33302031, 0x383a3530, 0x3a323820, -0x73687561, 0x6e672045, 0x78702024, 0x0, -0x0, 0x0, 0x0, 0x24486561, -0x6465723a, 0x202f7072, 0x6f6a6563, 0x74732f72, -0x63732f73, 0x772f6765, 0x2f2e2f6e, 0x69632f66, -0x77322f63, 0x6f6d6d6f, 0x6e2f6461, 0x74612e63, -0x2c762031, 0x2e312e32, 0x2e313220, 0x31393939, -0x2f30312f, 0x32302031, 0x393a3439, 0x3a353120, -0x73687561, 0x6e672045, 0x78702024, 0x0, -0x46575f56, 0x45525349, 0x4f4e3a20, 0x31322e34, -0x2e31315f, 0x46726565, 0x42534400, 0x46575f43, -0x4f4d5049, 0x4c455f54, 0x494d453a, 0x20576564, -0x204a756c, 0x20323620, 0x31303a34, 0x303a3331, -0x20504454, 0x20323030, 0x30000000, 0x46575f43, -0x4f4d5049, 0x4c455f42, 0x593a2077, 0x7061756c, -0x0, 0x46575f43, 0x4f4d5049, 0x4c455f48, -0x4f53543a, 0x20627261, 0x6b000000, 0x46575f43, -0x4f4d5049, 0x4c455f44, 0x4f4d4149, 0x4e3a2000, -0x46575f43, 0x4f4d5049, 0x4c45523a, 0x20526561, -0x64696e67, 0x20737065, 0x63732066, 0x726f6d20, -0x2f686f6d, 0x652f7770, 0x61756c2f, 0x616c7465, -0x6f6e2f74, 0x6f6f6c73, 0x2f6c6962, 0x2f676363, -0x2d6c6962, 0x2f6d6970, 0x732d616e, 0x792d656c, -0x662f322e, 0x372e322f, 0x73706563, 0x73206763, -0x63207665, 0x7273696f, 0x6e20322e, 0x372e3200, -0x0, 0x12041100, 0x0, 0x24486561, -0x6465723a, 0x202f7072, 0x6f6a6563, 0x74732f72, -0x63732f73, 0x772f6765, 0x2f2e2f6e, 0x69632f66, -0x77322f63, 0x6f6d6d6f, 0x6e2f6d65, 0x6d2e632c, -0x7620312e, 0x312e322e, 0x35203139, 0x39382f30, -0x392f3330, 0x2031383a, 0x35303a30, 0x38207368, -0x75616e67, 0x20457870, 0x20240000, 0x24486561, -0x6465723a, 0x202f7072, 0x6f6a6563, 0x74732f72, -0x63732f73, 0x772f6765, 0x2f2e2f6e, 0x69632f66, -0x77322f63, 0x6f6d6d6f, 0x6e2f7365, 0x6e642e63, -0x2c762031, 0x2e312e32, 0x2e343420, 0x31393938, -0x2f31322f, 0x32312030, 0x303a3333, 0x3a313820, -0x73687561, 0x6e672045, 0x78702024, 0x0, +0x6e734600, 0x51725072, 0x6f644600, 0x6164644d, +0x63447570, 0x0, 0x6164644d, 0x6346756c, +0x0, 0x64656c4d, 0x634e6f45, 0x0, +0x24486561, 0x6465723a, 0x202f7072, 0x6f6a6563, +0x74732f72, 0x63732f73, 0x772f6765, 0x2f2e2f6e, +0x69632f66, 0x77322f63, 0x6f6d6d6f, 0x6e2f646d, +0x612e632c, 0x7620312e, 0x312e322e, 0x32342031, +0x3939382f, 0x31322f32, 0x31203030, 0x3a33333a, +0x30392073, 0x6875616e, 0x67204578, 0x70202400, 0x65767452, 0x6e674600, 0x51657674, 0x46000000, 0x51657674, 0x505f4600, 0x4d657674, 0x526e6746, 0x0, 0x4d516576, 0x74460000, 0x4d516576, 0x505f4600, 0x5173436f, 0x6e495f46, 0x0, 0x5173436f, 0x6e734600, 0x51725072, 0x6f644600, +0x7377446d, 0x614f6666, 0x0, 0x31446d61, +0x4f6e0000, 0x7377446d, 0x614f6e00, 0x2a50414e, +0x49432a00, 0x646d612e, 0x63000000, 0x2372446d, +0x6141544e, 0x0, 0x72446d61, 0x41544e30, +0x0, 0x72446d61, 0x41544e31, 0x0, +0x72446d61, 0x34476200, 0x2377446d, 0x6141544e, +0x0, 0x77446d61, 0x41544e30, 0x0, +0x77446d61, 0x41544e31, 0x0, 0x77446d61, +0x34476200, 0x24486561, 0x6465723a, 0x202f7072, +0x6f6a6563, 0x74732f72, 0x63732f73, 0x772f6765, +0x2f2e2f6e, 0x69632f66, 0x77322f63, 0x6f6d6d6f, +0x6e2f7472, 0x6163652e, 0x632c7620, 0x312e312e, +0x322e3520, 0x31393938, 0x2f30392f, 0x33302031, +0x383a3530, 0x3a323820, 0x73687561, 0x6e672045, +0x78702024, 0x0, 0x24486561, 0x6465723a, +0x202f7072, 0x6f6a6563, 0x74732f72, 0x63732f73, +0x772f6765, 0x2f2e2f6e, 0x69632f66, 0x77322f63, +0x6f6d6d6f, 0x6e2f6461, 0x74612e63, 0x2c762031, +0x2e312e32, 0x2e313220, 0x31393939, 0x2f30312f, +0x32302031, 0x393a3439, 0x3a353120, 0x73687561, +0x6e672045, 0x78702024, 0x0, 0x46575f56, +0x45525349, 0x4f4e3a20, 0x58585800, 0x46575f43, +0x4f4d5049, 0x4c455f54, 0x494d453a, 0x20585858, +0x0, 0x46575f43, 0x4f4d5049, 0x4c455f42, +0x593a2058, 0x58580000, 0x46575f43, 0x4f4d5049, +0x4c455f48, 0x4f53543a, 0x20585858, 0x0, +0x46575f43, 0x4f4d5049, 0x4c455f44, 0x4f4d4149, +0x4e3a2058, 0x58580000, 0x46575f43, 0x4f4d5049, +0x4c45523a, 0x20585858, 0x0, 0x0, +0x12041300, 0x24486561, 0x6465723a, 0x202f7072, +0x6f6a6563, 0x74732f72, 0x63732f73, 0x772f6765, +0x2f2e2f6e, 0x69632f66, 0x77322f63, 0x6f6d6d6f, +0x6e2f6d65, 0x6d2e632c, 0x7620312e, 0x312e322e, +0x35203139, 0x39382f30, 0x392f3330, 0x2031383a, +0x35303a30, 0x38207368, 0x75616e67, 0x20457870, +0x20240000, 0x24486561, 0x6465723a, 0x202f7072, +0x6f6a6563, 0x74732f72, 0x63732f73, 0x772f6765, +0x2f2e2f6e, 0x69632f66, 0x77322f63, 0x6f6d6d6f, +0x6e2f7365, 0x6e642e63, 0x2c762031, 0x2e312e32, +0x2e343420, 0x31393938, 0x2f31322f, 0x32312030, +0x303a3333, 0x3a313820, 0x73687561, 0x6e672045, +0x78702024, 0x0, 0x65767452, 0x6e674600, +0x51657674, 0x46000000, 0x51657674, 0x505f4600, +0x4d657674, 0x526e6746, 0x0, 0x4d516576, +0x74460000, 0x4d516576, 0x505f4600, 0x5173436f, +0x6e495f46, 0x0, 0x5173436f, 0x6e734600, +0x51725072, 0x6f644600, 0x2a50414e, 0x49432a00, +0x6d61632e, 0x68000000, 0x73656e64, 0x2e630000, 0x69736e74, 0x54637055, 0x0, 0x24486561, 0x6465723a, 0x202f7072, 0x6f6a6563, 0x74732f72, 0x63732f73, 0x772f6765, 0x2f2e2f6e, 0x69632f66, @@ -4784,97 +5101,105 @@ 0x0, 0x4d516576, 0x74460000, 0x4d516576, 0x505f4600, 0x5173436f, 0x6e495f46, 0x0, 0x5173436f, 0x6e734600, 0x51725072, 0x6f644600, +0x2a50414e, 0x49432a00, 0x6d61632e, 0x68000000, 0x724d6163, 0x43686b30, 0x0, 0x72784672, 0x6d324c67, 0x0, 0x72784e6f, 0x53744264, 0x0, 0x72784e6f, 0x4d694264, 0x0, -0x72784e6f, 0x4a6d4264, 0x0, 0x7278436b, -0x446d6146, 0x0, 0x72785144, 0x6d457846, -0x0, 0x72785144, 0x6d614600, 0x72785144, -0x4c426446, 0x0, 0x72785144, 0x6d426446, -0x0, 0x72784372, 0x63506164, 0x0, -0x72536d51, 0x446d6146, 0x0, 0x24486561, -0x6465723a, 0x202f7072, 0x6f6a6563, 0x74732f72, -0x63732f73, 0x772f6765, 0x2f2e2f6e, 0x69632f66, -0x77322f63, 0x6f6d6d6f, 0x6e2f6d61, 0x632e632c, -0x7620312e, 0x312e322e, 0x32322031, 0x3939382f, -0x31322f30, 0x38203032, 0x3a33363a, 0x33302073, -0x6875616e, 0x67204578, 0x70202400, 0x65767452, -0x6e674600, 0x51657674, 0x46000000, 0x51657674, -0x505f4600, 0x4d657674, 0x526e6746, 0x0, -0x4d516576, 0x74460000, 0x4d516576, 0x505f4600, -0x5173436f, 0x6e495f46, 0x0, 0x5173436f, -0x6e734600, 0x51725072, 0x6f644600, 0x6d616354, -0x68726573, 0x0, 0x23744d61, 0x6341544e, -0x0, 0x23724d61, 0x6341544e, 0x0, -0x72656d41, 0x73737274, 0x0, 0x6c696e6b, +0x72784e6f, 0x4a6d4264, 0x0, 0x72656376, +0x2e630000, 0x7278436b, 0x446d6146, 0x0, +0x72785144, 0x6d457846, 0x0, 0x72785144, +0x6d614600, 0x72785144, 0x4c426446, 0x0, +0x72785144, 0x6d426446, 0x0, 0x72784372, +0x63506164, 0x0, 0x72536d51, 0x446d6146, +0x0, 0x24486561, 0x6465723a, 0x202f7072, +0x6f6a6563, 0x74732f72, 0x63732f73, 0x772f6765, +0x2f2e2f6e, 0x69632f66, 0x77322f63, 0x6f6d6d6f, +0x6e2f6d61, 0x632e632c, 0x7620312e, 0x312e322e, +0x32322031, 0x3939382f, 0x31322f30, 0x38203032, +0x3a33363a, 0x33302073, 0x6875616e, 0x67204578, +0x70202400, 0x65767452, 0x6e674600, 0x51657674, +0x46000000, 0x51657674, 0x505f4600, 0x4d657674, +0x526e6746, 0x0, 0x4d516576, 0x74460000, +0x4d516576, 0x505f4600, 0x5173436f, 0x6e495f46, +0x0, 0x5173436f, 0x6e734600, 0x51725072, +0x6f644600, 0x2a50414e, 0x49432a00, 0x6d61632e, +0x68000000, 0x6d616354, 0x68726573, 0x0, +0x23744d61, 0x6341544e, 0x0, 0x23724d61, +0x6341544e, 0x0, 0x72656d41, 0x73737274, +0x0, 0x6d61632e, 0x63000000, 0x6c696e6b, 0x444f574e, 0x0, 0x6c696e6b, 0x55500000, -0x0, 0x0, 0x0, 0x24486561, -0x6465723a, 0x202f7072, 0x6f6a6563, 0x74732f72, -0x63732f73, 0x772f6765, 0x2f2e2f6e, 0x69632f66, -0x77322f63, 0x6f6d6d6f, 0x6e2f636b, 0x73756d2e, -0x632c7620, 0x312e312e, 0x322e3920, 0x31393939, -0x2f30312f, 0x31342030, 0x303a3033, 0x3a343820, -0x73687561, 0x6e672045, 0x78702024, 0x0, -0x65767452, 0x6e674600, 0x51657674, 0x46000000, -0x51657674, 0x505f4600, 0x4d657674, 0x526e6746, -0x0, 0x4d516576, 0x74460000, 0x4d516576, -0x505f4600, 0x5173436f, 0x6e495f46, 0x0, -0x5173436f, 0x6e734600, 0x51725072, 0x6f644600, -0x0, 0x0, 0x0, 0x50726f62, -0x65506879, 0x0, 0x6c6e6b41, 0x53535254, -0x0, 0x6e6f4863, 0x644c6b00, 0x10994, -0x10a0c, 0x10a40, 0x10a6c, 0x10a98, -0x10b0c, 0x10b74, 0x112c8, 0x10ccc, -0x10d00, 0x10d18, 0x10d5c, 0x10d84, -0x10da4, 0x10dcc, 0x112c8, 0x10ccc, -0x10e58, 0x10e70, 0x10ea0, 0x10d84, -0x10ec8, 0x10ef0, 0x0, 0x1101c, -0x11048, 0x1106c, 0x112c8, 0x11090, -0x11144, 0x111d4, 0x0, 0x1192c, -0x119fc, 0x11ad4, 0x11ba4, 0x11c00, -0x11cdc, 0x11d04, 0x11de0, 0x11e08, -0x11fb0, 0x11fd8, 0x12180, 0x12378, -0x1260c, 0x12520, 0x1260c, 0x12638, -0x121a8, 0x12350, 0x7273745f, 0x676d6969, -0x0, 0x126c8, 0x12700, 0x127e8, -0x13434, 0x13474, 0x1348c, 0x7365746c, -0x6f6f7000, 0x0, 0x0, 0x13c7c, -0x13cbc, 0x13d4c, 0x13d90, 0x13df4, -0x13e80, 0x13eb4, 0x13f3c, 0x13fd4, -0x140a4, 0x140e4, 0x14168, 0x1418c, -0x1429c, 0x646f4261, 0x73655067, 0x0, -0x0, 0x0, 0x0, 0x73746d61, -0x634c4e4b, 0x0, 0x6765746d, 0x636c6e6b, -0x0, 0x14f98, 0x14f98, 0x14c4c, -0x14c98, 0x14ce4, 0x14f98, 0x7365746d, -0x61636163, 0x74000000, 0x0, 0x0 }; +0x24486561, 0x6465723a, 0x202f7072, 0x6f6a6563, +0x74732f72, 0x63732f73, 0x772f6765, 0x2f2e2f6e, +0x69632f66, 0x77322f63, 0x6f6d6d6f, 0x6e2f636b, +0x73756d2e, 0x632c7620, 0x312e312e, 0x322e3920, +0x31393939, 0x2f30312f, 0x31342030, 0x303a3033, +0x3a343820, 0x73687561, 0x6e672045, 0x78702024, +0x0, 0x65767452, 0x6e674600, 0x51657674, +0x46000000, 0x51657674, 0x505f4600, 0x4d657674, +0x526e6746, 0x0, 0x4d516576, 0x74460000, +0x4d516576, 0x505f4600, 0x5173436f, 0x6e495f46, +0x0, 0x5173436f, 0x6e734600, 0x51725072, +0x6f644600, 0x2a50414e, 0x49432a00, 0x6d61632e, +0x68000000, 0x2a50414e, 0x49432a00, 0x2e2e2f63, +0x6f6d6d6f, 0x6e2f6d61, 0x632e6800, 0x2e2e2f2e, +0x2e2f2e2e, 0x2f636f6d, 0x6d6f6e2f, 0x6c696e6b, +0x2e630000, 0x50726f62, 0x65506879, 0x0, +0x6c6e6b41, 0x53535254, 0x0, 0x6e6f4863, +0x644c6b00, 0x120d0, 0x12144, 0x12178, +0x121a4, 0x12220, 0x12298, 0x12300, +0x12abc, 0x124a0, 0x124d8, 0x124f0, +0x12534, 0x1255c, 0x12580, 0x125a8, +0x12abc, 0x124a0, 0x12634, 0x1264c, +0x1267c, 0x1255c, 0x126a4, 0x126cc, +0x0, 0x12800, 0x12830, 0x12854, +0x12abc, 0x12878, 0x12934, 0x129c8, +0x0, 0x2a50414e, 0x49432a00, 0x2e2e2f63, +0x6f6d6d6f, 0x6e2f6d61, 0x632e6800, 0x1325c, +0x1332c, 0x13404, 0x134d4, 0x13530, +0x1360c, 0x1364c, 0x13728, 0x13750, +0x138f8, 0x13920, 0x13ac8, 0x13cc0, +0x13f58, 0x13e68, 0x13f58, 0x13f84, +0x13af0, 0x13c98, 0x0, 0x13f78, +0x13f78, 0x13520, 0x13528, 0x13f78, +0x13f78, 0x13520, 0x7273745f, 0x676d6969, +0x0, 0x14050, 0x1408c, 0x14178, +0x14c10, 0x14c54, 0x14c6c, 0x7365746c, +0x6f6f7000, 0x2a50414e, 0x49432a00, 0x2e2e2f63, +0x6f6d6d6f, 0x6e2f6d61, 0x632e6800, 0x15338, +0x15378, 0x15410, 0x15454, 0x154c0, +0x15550, 0x15584, 0x15610, 0x156b4, +0x15784, 0x157c4, 0x15850, 0x15874, +0x1598c, 0x646f4261, 0x73655067, 0x0, +0x0, 0x2a50414e, 0x49432a00, 0x2e2e2f63, +0x6f6d6d6f, 0x6e2f6d61, 0x632e6800, 0x676c6e6b, +0x6d696900, 0x6765746d, 0x636c6e6b, 0x0, +0x676c6e6b, 0x676d6969, 0x0, 0x166e8, +0x166e8, 0x16368, 0x163ac, 0x16408, +0x166e8, 0x16368, 0x7365746d, 0x61636163, +0x74000000, 0x0 }; static u_int32_t tigon2FwData[] = { 0x1, 0x1, 0x1, 0xc001fc, 0x3ffc, -0xc00000, 0x46726565, 0x42534420, 0x5469676f, -0x6e203200, 0x0, 0x0, 0x0, -0x0, 0x0, 0x0, 0x46726565, -0x42534420, 0x5469676f, 0x6e203200, 0x42424242, -0x0, 0x0, 0x0, 0x1ffffc, +0xc00000, 0x416c7465, 0x6f6e2041, 0x63654e49, +0x43205600, 0x0, 0x416c7465, 0x6f6e2041, +0x63654e49, 0x43205600, 0x42424242, 0x1ffffc, 0x1fff7c, 0x0, 0x0, 0x0, -0x0, 0x0, 0x0, 0x60cf00, -0x60, 0xcf000000, 0x0, 0x0, +0x60cf00, 0x60, 0xcf000000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, -0x0, 0x0, 0x3, 0x0, -0x1, 0x0, 0x0, 0x0, -0x1, 0x0, 0x1, 0x0, +0x0, 0x0, 0x0, 0x3, +0x0, 0x1, 0x0, 0x0, +0x0, 0x1, 0x0, 0x1, +0x0, 0x0, 0x1, 0x1, +0x0, 0x0, 0x0, 0x0, +0x0, 0x1000000, 0x21000000, 0x12000140, +0x0, 0x0, 0x20000000, 0x120000a0, +0x0, 0x12000060, 0x12000180, 0x120001e0, 0x0, 0x0, 0x0, 0x1, -0x1, 0x0, 0x0, 0x0, -0x0, 0x0, 0x1000000, 0x21000000, -0x12000140, 0x0, 0x0, 0x20000000, -0x120000a0, 0x0, 0x12000060, 0x12000180, -0x120001e0, 0x0, 0x0, 0x0, -0x1, 0x0, 0x0, 0x0, -0x0, 0x0, 0x0, 0x2, -0x0, 0x0, 0x30001, 0x1, -0x30201, 0x0, 0x0, 0x1010101, +0x0, 0x0, 0x0, 0x0, +0x2, 0x0, 0x0, 0x30001, +0x1, 0x30201, 0x0, 0x1010101, 0x1010100, 0x10100, 0x1010001, 0x10001, 0x1000101, 0x101, 0x0, 0x0 }; Index: sys/mbuf.h =================================================================== RCS file: /home/ncvs/src/sys/sys/mbuf.h,v retrieving revision 1.44.2.8 diff -u -r1.44.2.8 mbuf.h --- sys/mbuf.h 2001/02/04 14:49:59 1.44.2.8 +++ sys/mbuf.h 2001/05/17 18:55:21 @@ -581,6 +581,16 @@ struct mbuf *m_aux_add __P((struct mbuf *, int, int)); struct mbuf *m_aux_find __P((struct mbuf *, int, int)); void m_aux_delete __P((struct mbuf *, struct mbuf *)); + +void jumbo_ref __P((caddr_t, u_int)); +void jumbo_freem __P((caddr_t, u_int)); +void jumbo_pg_free __P((vm_offset_t)); +void jumbo_pg_steal __P((vm_page_t)); +vm_page_t jumbo_pg_alloc __P((void)); +int jumbo_vm_init __P((void)); +caddr_t jumbo_phys_to_kva __P((vm_offset_t)); +int jumbo_disposable __P((caddr_t)); + #endif /* _KERNEL */ #endif /* !_SYS_MBUF_H_ */ Index: sys/socketvar.h =================================================================== RCS file: /home/ncvs/src/sys/sys/socketvar.h,v retrieving revision 1.46.2.5 diff -u -r1.46.2.5 socketvar.h --- sys/socketvar.h 2001/02/26 04:23:21 1.46.2.5 +++ sys/socketvar.h 2001/05/17 19:56:33 @@ -359,6 +359,7 @@ int soclose __P((struct socket *so)); int soconnect __P((struct socket *so, struct sockaddr *nam, struct proc *p)); int soconnect2 __P((struct socket *so1, struct socket *so2)); +int socow_setup __P((struct mbuf *m0, struct uio *uio)); int socreate __P((int dom, struct socket **aso, int type, int proto, struct proc *p)); void sodealloc __P((struct socket *so)); Index: sys/uio.h =================================================================== RCS file: /home/ncvs/src/sys/sys/uio.h,v retrieving revision 1.11 diff -u -r1.11 uio.h --- sys/uio.h 1999/12/29 04:24:49 1.11 +++ sys/uio.h 2001/05/17 19:34:39 @@ -77,7 +77,7 @@ struct vm_object; int uiomove __P((caddr_t, int, struct uio *)); -int uiomoveco __P((caddr_t, int, struct uio *, struct vm_object *)); +int uiomoveco __P((caddr_t, int, struct uio *, struct vm_object *, int)); int uioread __P((int, struct uio *, struct vm_object *, int *)); #else /* !_KERNEL */ Index: ufs/ufs/ufs_readwrite.c =================================================================== RCS file: /home/ncvs/src/sys/ufs/ufs/ufs_readwrite.c,v retrieving revision 1.65.2.6 diff -u -r1.65.2.6 ufs_readwrite.c --- ufs/ufs/ufs_readwrite.c 2000/12/30 01:51:11 1.65.2.6 +++ ufs/ufs/ufs_readwrite.c 2001/05/17 19:49:07 @@ -304,7 +304,7 @@ */ error = uiomoveco((char *)bp->b_data + blkoffset, - (int)xfersize, uio, object); + (int)xfersize, uio, object, 0); } else #endif { Index: vm/vm_fault.c =================================================================== RCS file: /home/ncvs/src/sys/vm/vm_fault.c,v retrieving revision 1.108.2.5 diff -u -r1.108.2.5 vm_fault.c --- vm/vm_fault.c 2001/03/14 07:05:05 1.108.2.5 +++ vm/vm_fault.c 2001/05/17 20:07:52 @@ -288,6 +288,20 @@ fs.m = vm_page_lookup(fs.object, fs.pindex); if (fs.m != NULL) { int queue, s; + + /* + * check for page-based copy on write + */ + + if ((fs.m->cow) && + (fault_type & VM_PROT_WRITE)) { + s = splvm(); + vm_page_cowfault(fs.m); + splx(s); + unlock_things(&fs); + goto RetryFault; + } + /* * Wait/Retry if the page is busy. We have to do this * if the page is busy via either PG_BUSY or Index: vm/vm_page.c =================================================================== RCS file: /home/ncvs/src/sys/vm/vm_page.c,v retrieving revision 1.147.2.6 diff -u -r1.147.2.6 vm_page.c --- vm/vm_page.c 2001/03/03 23:06:09 1.147.2.6 +++ vm/vm_page.c 2001/05/17 20:10:44 @@ -1958,6 +1958,84 @@ alignment, 0ul, kernel_map)); } +int so_zerocp_fullpage = 0; + +void +vm_page_cowfault(m) + vm_page_t m; +{ + vm_page_t mnew; + vm_object_t object; + vm_pindex_t pindex; + + object = m->object; + pindex = m->pindex; + vm_page_busy(m); + + retry_alloc: + vm_page_remove(m); + mnew = vm_page_alloc(object, pindex, VM_ALLOC_NORMAL); + if (mnew == NULL) { + vm_page_insert(m, object, pindex); + VM_WAIT; + goto retry_alloc; + } + + if (m->cow == 0) { + /* + * check to see if we raced with an xmit complete when + * waiting to allocate a page. If so, put things back + * the way they were + */ + vm_page_busy(mnew); + vm_page_free(mnew); + vm_page_insert(m, object, pindex); + } else { /* clear COW & copy page */ + if (so_zerocp_fullpage) { + mnew->valid = VM_PAGE_BITS_ALL; + } else { + vm_page_copy(m, mnew); + } + vm_page_dirty(mnew); + vm_page_flag_clear(mnew, PG_BUSY); + } + vm_page_wakeup(m); /*unbusy the page */ +} + +void +vm_page_cowclear(m) + vm_page_t m; + +{ + int s = splvm(); + + if (m->cow) { + atomic_subtract_char(&m->cow, 1); + /* + * let vm_fault add back write permission lazily + */ + } + /* + * sf_buf_free() will free the page, so we needn't do it here + */ + + splx(s); +} + +void +vm_page_cowsetup(m) + vm_page_t m; + +{ + int s = splvm(); + + atomic_add_char(&m->cow, 1); + vm_page_protect(m, VM_PROT_READ); + + splx(s); +} + + #include "opt_ddb.h" #ifdef DDB #include Index: vm/vm_page.h =================================================================== RCS file: /home/ncvs/src/sys/vm/vm_page.h,v retrieving revision 1.75.2.5 diff -u -r1.75.2.5 vm_page.h --- vm/vm_page.h 2000/12/30 01:51:11 1.75.2.5 +++ vm/vm_page.h 2001/05/17 20:09:38 @@ -134,6 +134,7 @@ u_short valid; /* map of valid DEV_BSIZE chunks */ u_short dirty; /* map of dirty DEV_BSIZE chunks */ #endif + u_char cow; /* page cow mapping count */ }; /* @@ -437,6 +438,9 @@ #endif void vm_page_zero_invalid(vm_page_t m, boolean_t setvalid); void vm_page_free_toq(vm_page_t m); +void vm_page_cowfault __P((vm_page_t)); +void vm_page_cowsetup __P((vm_page_t)); +void vm_page_cowclear __P((vm_page_t)); /* * Keep page from being freed by the page daemon --- /dev/null Tue Jul 10 02:07:02 2001 +++ kern/embuf.c Tue May 1 17:31:27 2001 @@ -0,0 +1,450 @@ +/* + * embuf.c + * + * a simple interface to wrap BSD style mbuf chains around (1.) arbitrary + * (non-aligned) kernel virtual address ranges, or (2.) vm_page arrays. + * supports a single iocompletion with argument, invoked when the last + * mbuf in the chain is freed. + * + * like sfbufs and if_tpz, allocate a private kernel virtual address range + * for vm_page mapping. mapping in this range couples addresses with + * managing structures for fast lookup. + */ + +/* + * Copyright (c) 2000 Duke University -- Darrell Anderson + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by Duke University + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#define EMBSANITY 0x00042777 /* constant for emb integrity checking */ +#define EMBSIZE 4096 /* limit on outstanding emb mbufs */ +#define EMBHASHSIZE 16 /* hash table buckets */ +#define EMBHASH(addr) ((atop(addr)) % EMBHASHSIZE) /* hash function */ + +static struct embrec { + u_int32_t sanity; /* some bulletproofing shoe polish */ + int refcnt; /* outstanding references to mbuf */ + caddr_t addr; /* data address (kva) */ + u_int32_t len; /* data length, in bytes */ + + void (*iocomp)(void *, int, caddr_t); /* iocompletion */ + caddr_t arg; /* iocompletion argument */ + + struct embrec *head; /* point back to first for mbuf chain */ + + vm_page_t embp; /* embp page or NULL if normal emb */ + caddr_t embp_kva; /* reserved address for embp mapping */ + + struct mbuf *m; /* the emb mbuf */ + + LIST_ENTRY(embrec) hashlist; + LIST_ENTRY(embrec) freelist; +} *embrecs = NULL; +static LIST_HEAD(emblist_head, embrec) emb_hash[EMBHASHSIZE]; +static LIST_HEAD(embfreelist_head, embrec) emb_freelist; +static int emb_freelist_wanted; +static caddr_t embp_basekva; + +static int emb_refcnt = 0; +SYSINIT(em, SI_SUB_MBUF, SI_ORDER_MIDDLE, emb_init, NULL) + +void +emb_init(void *arg) +{ + struct embrec *emb; + int i; + + if (emb_refcnt++) { + return; /* already initialized */ + } + + LIST_INIT(&emb_freelist); + for (i=0 ; iembp_kva = embp_basekva + ptoa(i); + emb->sanity = EMBSANITY; + LIST_INSERT_HEAD(&emb_freelist, emb, freelist); + } + emb_freelist_wanted = 0; +} + +void +emb_uninit(void) +{ + if (--emb_refcnt) { + printf("emb_uninit warning: emb_refcnt=%d\n", emb_refcnt); + return; /* other users still hold reference(s) */ + } + + kmem_free(kernel_map, (vm_offset_t)embp_basekva, ptoa(EMBSIZE)); + FREE(embrecs, M_TEMP); +} + +static __inline struct embrec * +emb_getfree(int waitok) +{ + struct embrec *emb; + int s = splimp(); + while ((emb = LIST_FIRST(&emb_freelist)) == NULL && waitok) { + emb_freelist_wanted = 1; + tsleep(&emb_freelist_wanted, PWAIT, "emb", 0); + } + if (emb) { + LIST_REMOVE(emb, freelist); + } + splx(s); +#if !defined(MAX_PERF) + if (emb && emb->sanity != EMBSANITY) { + panic("emb_getfree: bad sanity"); + } +#endif + return emb; +} + +static __inline struct embrec * +emb_find(caddr_t addr, u_int len) +{ + struct embrec *emb; + + if (addr >= embp_basekva && addr < embp_basekva + ptoa(EMBSIZE)) { + emb = &embrecs[atop(addr - embp_basekva)]; +#if !defined(MAX_PERF) + if (emb->addr != addr || emb->len != len) { + panic("emb_find: embp address, but wrong embp"); + } +#endif + } else { + emb = LIST_FIRST(&emb_hash[EMBHASH(addr)]); + while (emb && (emb->addr != addr || emb->len != len)) { + emb = LIST_NEXT(emb, hashlist); + } + } +#if !defined(MAX_PERF) + if (emb && emb->sanity != EMBSANITY) { + panic("emb_find: bad sanity"); + } +#endif + return emb; +} + +static void +emb_ref(caddr_t addr, u_int len) +{ + int s = splimp(); + struct embrec *emb = emb_find(addr, len); +#if !defined(MAX_PERF) + if (emb == NULL) { + panic("emb_ref: no record found to reference"); + } +#endif + emb->refcnt++; + splx(s); +} + +static void +emb_iodone(caddr_t addr, u_int len) +{ + int s = splimp(); + struct embrec *emb = emb_find(addr, len); +#if !defined(MAX_PERF) + if (emb == NULL) { + panic("emb_iodone: no record found to release"); + } + if (emb->refcnt <= 0) { + panic("emb_iodone: record has no references to release"); + } + if (emb->iocomp && emb->head) { + panic("emb_iodone: didn't expect emb with iocomp AND head"); + } +#endif + if (--(emb->refcnt) == 0) { + LIST_REMOVE(emb, hashlist); + splx(s); + if (emb->embp) { + pmap_qremove((vm_offset_t)emb->embp_kva, 1); + } + if (emb->iocomp) { + (*emb->iocomp)(NULL, 0, emb->arg); + } + if (emb->head) { /* part of mbuf tail, tell head we're free */ + emb_iodone(emb->head->addr, emb->head->len); + } + s = splimp(); + LIST_INSERT_HEAD(&emb_freelist, emb, freelist); + if (emb_freelist_wanted) { + emb_freelist_wanted = 0; + wakeup(&emb_freelist_wanted); + } + } + splx(s); +} + +/* + * [emb_get -- external mbuf get] + * + * allocate an external mbuf chain (blocking if permitted and necessary), + * wrap it around the specified address and length. caller may specify an + * iocompletion routine (and its argument) to be invoked after all mbufs in + * the chain are freed. + * + * the result may be a single mbuf, or a chain of mbufs. if the specified + * data range crosses one or more page boundaries, allocate a separate mbuf + * for each page. if there is a chain of mbufs, delay the iocompletion + * until all mbufs in the chain are freed. + * + * warning: calling emb_get on overlapping regions may misbehave. + * + * PARAMETERS + * -> addr data address (kva) + * -> len data length, in bytes + * -> iocomp the iocompletion routine + * -> arg iocompletion argument + * -> waitok should allocation block? (M_WAITOK or M_NOWAIT) + * + * RETURNS: + * struct mbuf * an external mbuf chain, or NULL on failure + */ +struct mbuf * +emb_get(caddr_t addr, int len, void (*iocomp)(void *, int, caddr_t), + caddr_t arg, int waitok) +{ + struct embrec *emb = NULL, *embhead = NULL; + struct mbuf *mret = NULL; + int s, thislen, off, pgoff; + volatile char debugtest; + +#if !defined(MAX_PERF) + if (embrecs == NULL) { + panic("emb_get: emb_init has not been called yet!"); + } + if (len <= 0) { + panic("invalid len (%d)", len); + } + + /* + * make sure no existing emb's cover the requested address space. + */ + for (off = 0 ; off < len ; off += thislen) { + pgoff = (long)(addr+off) & (PAGE_SIZE - 1); + thislen = min(len - off, PAGE_SIZE - pgoff); + s = splimp(); + if ((emb = emb_find(addr + off, thislen)) != NULL) { + if (bootverbose ) + printf("emb_get overlaps with existing emb region\n"); + /*panic("emb_get overlaps with existing emb region");*/ + splx(s); + return NULL; /* don't die.. caller must handle this */ + } + splx(s); + } +#endif + + for (off = 0 ; off < len ; off += thislen) { + pgoff = (long)(addr+off) & (PAGE_SIZE - 1); + thislen = min(len - off, PAGE_SIZE - pgoff); + + if ((emb = emb_getfree(waitok)) == NULL) { + goto abort; + } + emb->embp = NULL; /* mark as emb */ + emb->refcnt = 1; + emb->addr = addr + off; + emb->len = (u_int)thislen; + + if ((emb->m = m_get(waitok, MT_DATA)) == NULL) { + goto abort; + } + emb->m->m_flags |= M_EXT; + emb->m->m_data = emb->m->m_ext.ext_buf = emb->addr; + emb->m->m_len = emb->m->m_ext.ext_size = emb->len; + emb->m->m_ext.ext_free = emb_iodone; + emb->m->m_ext.ext_ref = emb_ref; + +#if !defined(MAX_PERF) + debugtest = *((char *)emb->m->m_ext.ext_buf); +#endif + + if (embhead == NULL) { + embhead = emb; + emb->head = NULL; + + emb->iocomp = iocomp; + emb->arg = arg; + mret = emb->m; + } else { + embhead->refcnt++; + emb->head = embhead; + + emb->iocomp = NULL; + emb->arg = NULL; + m_cat(mret, emb->m); + } + s = splimp(); + LIST_INSERT_HEAD(&emb_hash[EMBHASH(emb->addr)], emb, hashlist); + splx(s); + } + mret->m_flags |= M_PKTHDR; + mret->m_pkthdr.aux = (struct mbuf *)NULL; + mret->m_pkthdr.rcvif = NULL; + mret->m_pkthdr.csum_flags = 0; + mret->m_pkthdr.len = len; + return mret; + + abort: + printf("emb_get: aborting\n"); + for (off = 0 ; off < len ; off += thislen) { + pgoff = (long)(addr+off) & (PAGE_SIZE - 1); + thislen = min(len - off, PAGE_SIZE - pgoff); + s = splimp(); + if ((emb = emb_find(addr + off, thislen)) != NULL) { + LIST_REMOVE(emb, hashlist); + LIST_INSERT_HEAD(&emb_freelist, emb, freelist); + } + splx(s); + } + m_freem(mret); + return NULL; +} + +/* + * [embp_get -- external mbuf get for vm pages, almost a clone of emb_get] + * + * allocate an external mbuf chain (blocking if permitted and necessary), + * wrap it around the specified pages. caller may specify an iocompletion + * routine (and its argument) to be invoked after all mbufs in the chain + * are freed. + * + * PARAMETERS + * -> pages page array to map and wrap mbufs around + * -> npages size of page array, in pages + * -> iocomp the iocompletion routine + * -> arg iocompletion argument + * -> waitok should allocation block? (M_WAITOK or M_NOWAIT) + * + * RETURNS: + * struct mbuf * an external mbuf chain, or NULL on failure + */ +struct mbuf * +embp_get(vm_page_t *pages, int npages, void (*iocomp)(void *, int, caddr_t), + caddr_t arg, int waitok) +{ + struct embrec *emb = NULL, *embhead = NULL; + struct mbuf *mret = NULL; + int s, i; + volatile char debugtest; + +#if !defined(MAX_PERF) + if (embrecs == NULL) { + panic("emb_get: emb_init has not been called yet!"); + } +#endif + + for (i=0 ; iembp = pages[i]; /* mark as embp */ + pmap_qenter((vm_offset_t)emb->embp_kva, &emb->embp, 1); + emb->refcnt = 1; + emb->addr = emb->embp_kva; + emb->len = PAGE_SIZE; + + if ((emb->m = m_get(waitok, MT_DATA)) == NULL) { + panic("embp_get: m_get failed"); + } + emb->m->m_flags |= M_EXT; + emb->m->m_data = emb->m->m_ext.ext_buf = emb->addr; + emb->m->m_len = emb->m->m_ext.ext_size = emb->len; + emb->m->m_ext.ext_free = emb_iodone; + emb->m->m_ext.ext_ref = emb_ref; + +#if !defined(MAX_PERF) + debugtest = *((char *)emb->m->m_ext.ext_buf); +#endif + + if (embhead == NULL) { + embhead = emb; + emb->head = NULL; + + emb->iocomp = iocomp; + emb->arg = arg; + mret = emb->m; + } else { + embhead->refcnt++; + emb->head = embhead; + + emb->iocomp = NULL; + emb->arg = NULL; + m_cat(mret, emb->m); + } + s = splimp(); + LIST_INSERT_HEAD(&emb_hash[EMBHASH(emb->addr)], emb, hashlist); + splx(s); + } + mret->m_flags |= M_PKTHDR; + mret->m_pkthdr.len = ptoa(npages); + return mret; +} --- /dev/null Tue Jul 10 02:07:02 2001 +++ kern/embuf.h Tue May 1 16:35:33 2001 @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2000 Duke University -- Darrell Anderson + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by Duke University + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +void emb_init __P((void*)); +void emb_uninit __P((void)); + +/* + * [emb_get -- external mbuf get] + * + * allocate an external mbuf chain (blocking if permitted and necessary), + * wrap it around the specified address and length. caller may specify an + * iocompletion routine (and its argument) to be invoked after all mbufs in + * the chain are freed. + * + * the result may be a single mbuf, or a chain of mbufs. if the specified + * data range crosses one or more page boundaries, allocate a separate mbuf + * for each page. if there is a chain of mbufs, delay the iocompletion + * until all mbufs in the chain are freed. + * + * warning: calling emb_get on overlapping regions may misbehave. + * + * PARAMETERS + * -> addr data address (kva) + * -> len data length, in bytes + * -> iocomp the iocompletion routine + * -> arg iocompletion argument + * -> waitok should allocation block? (M_WAITOK or M_NOWAIT) + * + * RETURNS: + * struct mbuf * an external mbuf chain, or NULL on failure + */ +struct mbuf *emb_get __P((caddr_t addr, int len, + void (*iocomp)(void *, int, caddr_t), + caddr_t arg, int waitok)); + +/* + * [embp_get -- external mbuf get for vm pages, almost a clone of emb_get] + * + * allocate an external mbuf chain (blocking if permitted and necessary), + * wrap it around the specified pages. caller may specify an iocompletion + * routine (and its argument) to be invoked after all mbufs in the chain + * are freed. + * + * PARAMETERS + * -> pages page array to map and wrap mbufs around + * -> npages size of page array, in pages + * -> iocomp the iocompletion routine + * -> arg iocompletion argument + * -> waitok should allocation block? (M_WAITOK or M_NOWAIT) + * + * RETURNS: + * struct mbuf * an external mbuf chain, or NULL on failure + */ +struct mbuf *embp_get __P((vm_page_t *pages, int npages, + void (*iocomp)(void *, int, caddr_t), + caddr_t arg, int waitok)); --- /dev/null Tue Jul 10 02:07:02 2001 +++ sys/tiio.h Mon May 14 11:32:41 2001 @@ -0,0 +1,333 @@ +/*- + * Copyright (c) 1999, 2000 Kenneth D. Merry. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions, and the following disclaimer, + * without modification, immediately at the beginning of the file. + * 2. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ +/* + * The ti_stats structure below is from code with the following copyright, + * and originally comes from the Alteon firmware documentation. + */ +/* + * Copyright (c) 1997, 1998, 1999 + * Bill Paul . All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by Bill Paul. + * 4. Neither the name of the author nor the names of any co-contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + * + * from: if_tireg.h,v 1.8 1999/07/23 18:46:24 wpaul Exp $ + */ + +#ifndef _SYS_TIIO_H_ +#define _SYS_TIIO_H_ + +#include + +/* + * Tigon statistics counters. + */ +struct ti_stats { + /* + * MAC stats, taken from RFC 1643, ethernet-like MIB + */ + volatile u_int32_t dot3StatsAlignmentErrors; /* 0 */ + volatile u_int32_t dot3StatsFCSErrors; /* 1 */ + volatile u_int32_t dot3StatsSingleCollisionFrames; /* 2 */ + volatile u_int32_t dot3StatsMultipleCollisionFrames; /* 3 */ + volatile u_int32_t dot3StatsSQETestErrors; /* 4 */ + volatile u_int32_t dot3StatsDeferredTransmissions; /* 5 */ + volatile u_int32_t dot3StatsLateCollisions; /* 6 */ + volatile u_int32_t dot3StatsExcessiveCollisions; /* 7 */ + volatile u_int32_t dot3StatsInternalMacTransmitErrors; /* 8 */ + volatile u_int32_t dot3StatsCarrierSenseErrors; /* 9 */ + volatile u_int32_t dot3StatsFrameTooLongs; /* 10 */ + volatile u_int32_t dot3StatsInternalMacReceiveErrors; /* 11 */ + /* + * interface stats, taken from RFC 1213, MIB-II, interfaces group + */ + volatile u_int32_t ifIndex; /* 12 */ + volatile u_int32_t ifType; /* 13 */ + volatile u_int32_t ifMtu; /* 14 */ + volatile u_int32_t ifSpeed; /* 15 */ + volatile u_int32_t ifAdminStatus; /* 16 */ +#define IF_ADMIN_STATUS_UP 1 +#define IF_ADMIN_STATUS_DOWN 2 +#define IF_ADMIN_STATUS_TESTING 3 + volatile u_int32_t ifOperStatus; /* 17 */ +#define IF_OPER_STATUS_UP 1 +#define IF_OPER_STATUS_DOWN 2 +#define IF_OPER_STATUS_TESTING 3 +#define IF_OPER_STATUS_UNKNOWN 4 +#define IF_OPER_STATUS_DORMANT 5 + volatile u_int32_t ifLastChange; /* 18 */ + volatile u_int32_t ifInDiscards; /* 19 */ + volatile u_int32_t ifInErrors; /* 20 */ + volatile u_int32_t ifInUnknownProtos; /* 21 */ + volatile u_int32_t ifOutDiscards; /* 22 */ + volatile u_int32_t ifOutErrors; /* 23 */ + volatile u_int32_t ifOutQLen; /* deprecated */ /* 24 */ + volatile u_int8_t ifPhysAddress[8]; /* 8 bytes */ /* 25 - 26 */ + volatile u_int8_t ifDescr[32]; /* 27 - 34 */ + u_int32_t alignIt; /* align to 64 bit for u_int64_ts following */ + /* + * more interface stats, taken from RFC 1573, MIB-IIupdate, + * interfaces group + */ + volatile u_int64_t ifHCInOctets; /* 36 - 37 */ + volatile u_int64_t ifHCInUcastPkts; /* 38 - 39 */ + volatile u_int64_t ifHCInMulticastPkts; /* 40 - 41 */ + volatile u_int64_t ifHCInBroadcastPkts; /* 42 - 43 */ + volatile u_int64_t ifHCOutOctets; /* 44 - 45 */ + volatile u_int64_t ifHCOutUcastPkts; /* 46 - 47 */ + volatile u_int64_t ifHCOutMulticastPkts; /* 48 - 49 */ + volatile u_int64_t ifHCOutBroadcastPkts; /* 50 - 51 */ + volatile u_int32_t ifLinkUpDownTrapEnable; /* 52 */ + volatile u_int32_t ifHighSpeed; /* 53 */ + volatile u_int32_t ifPromiscuousMode; /* 54 */ + volatile u_int32_t ifConnectorPresent; /* follow link state 55 */ + /* + * Host Commands + */ + volatile u_int32_t nicCmdsHostState; /* 56 */ + volatile u_int32_t nicCmdsFDRFiltering; /* 57 */ + volatile u_int32_t nicCmdsSetRecvProdIndex; /* 58 */ + volatile u_int32_t nicCmdsUpdateGencommStats; /* 59 */ + volatile u_int32_t nicCmdsResetJumboRing; /* 60 */ + volatile u_int32_t nicCmdsAddMCastAddr; /* 61 */ + volatile u_int32_t nicCmdsDelMCastAddr; /* 62 */ + volatile u_int32_t nicCmdsSetPromiscMode; /* 63 */ + volatile u_int32_t nicCmdsLinkNegotiate; /* 64 */ + volatile u_int32_t nicCmdsSetMACAddr; /* 65 */ + volatile u_int32_t nicCmdsClearProfile; /* 66 */ + volatile u_int32_t nicCmdsSetMulticastMode; /* 67 */ + volatile u_int32_t nicCmdsClearStats; /* 68 */ + volatile u_int32_t nicCmdsSetRecvJumboProdIndex; /* 69 */ + volatile u_int32_t nicCmdsSetRecvMiniProdIndex; /* 70 */ + volatile u_int32_t nicCmdsRefreshStats; /* 71 */ + volatile u_int32_t nicCmdsUnknown; /* 72 */ + /* + * NIC Events + */ + volatile u_int32_t nicEventsNICFirmwareOperational; /* 73 */ + volatile u_int32_t nicEventsStatsUpdated; /* 74 */ + volatile u_int32_t nicEventsLinkStateChanged; /* 75 */ + volatile u_int32_t nicEventsError; /* 76 */ + volatile u_int32_t nicEventsMCastListUpdated; /* 77 */ + volatile u_int32_t nicEventsResetJumboRing; /* 78 */ + /* + * Ring manipulation + */ + volatile u_int32_t nicRingSetSendProdIndex; /* 79 */ + volatile u_int32_t nicRingSetSendConsIndex; /* 80 */ + volatile u_int32_t nicRingSetRecvReturnProdIndex; /* 81 */ + /* + * Interrupts + */ + volatile u_int32_t nicInterrupts; /* 82 */ + volatile u_int32_t nicAvoidedInterrupts; /* 83 */ + /* + * BD Coalessing Thresholds + */ + volatile u_int32_t nicEventThresholdHit; /* 84 */ + volatile u_int32_t nicSendThresholdHit; /* 85 */ + volatile u_int32_t nicRecvThresholdHit; /* 86 */ + /* + * DMA Attentions + */ + volatile u_int32_t nicDmaRdOverrun; /* 87 */ + volatile u_int32_t nicDmaRdUnderrun; /* 88 */ + volatile u_int32_t nicDmaWrOverrun; /* 89 */ + volatile u_int32_t nicDmaWrUnderrun; /* 90 */ + volatile u_int32_t nicDmaWrMasterAborts; /* 91 */ + volatile u_int32_t nicDmaRdMasterAborts; /* 92 */ + /* + * NIC Resources + */ + volatile u_int32_t nicDmaWriteRingFull; /* 93 */ + volatile u_int32_t nicDmaReadRingFull; /* 94 */ + volatile u_int32_t nicEventRingFull; /* 95 */ + volatile u_int32_t nicEventProducerRingFull; /* 96 */ + volatile u_int32_t nicTxMacDescrRingFull; /* 97 */ + volatile u_int32_t nicOutOfTxBufSpaceFrameRetry; /* 98 */ + volatile u_int32_t nicNoMoreWrDMADescriptors; /* 99 */ + volatile u_int32_t nicNoMoreRxBDs; /* 100 */ + volatile u_int32_t nicNoSpaceInReturnRing; /* 101 */ + volatile u_int32_t nicSendBDs; /* current count 102 */ + volatile u_int32_t nicRecvBDs; /* current count 103 */ + volatile u_int32_t nicJumboRecvBDs; /* current count 104 */ + volatile u_int32_t nicMiniRecvBDs; /* current count 105 */ + volatile u_int32_t nicTotalRecvBDs; /* current count 106 */ + volatile u_int32_t nicTotalSendBDs; /* current count 107 */ + volatile u_int32_t nicJumboSpillOver; /* 108 */ + volatile u_int32_t nicSbusHangCleared; /* 109 */ + volatile u_int32_t nicEnqEventDelayed; /* 110 */ + /* + * Stats from MAC rx completion + */ + volatile u_int32_t nicMacRxLateColls; /* 111 */ + volatile u_int32_t nicMacRxLinkLostDuringPkt; /* 112 */ + volatile u_int32_t nicMacRxPhyDecodeErr; /* 113 */ + volatile u_int32_t nicMacRxMacAbort; /* 114 */ + volatile u_int32_t nicMacRxTruncNoResources; /* 115 */ + /* + * Stats from the mac_stats area + */ + volatile u_int32_t nicMacRxDropUla; /* 116 */ + volatile u_int32_t nicMacRxDropMcast; /* 117 */ + volatile u_int32_t nicMacRxFlowControl; /* 118 */ + volatile u_int32_t nicMacRxDropSpace; /* 119 */ + volatile u_int32_t nicMacRxColls; /* 120 */ + /* + * MAC RX Attentions + */ + volatile u_int32_t nicMacRxTotalAttns; /* 121 */ + volatile u_int32_t nicMacRxLinkAttns; /* 122 */ + volatile u_int32_t nicMacRxSyncAttns; /* 123 */ + volatile u_int32_t nicMacRxConfigAttns; /* 124 */ + volatile u_int32_t nicMacReset; /* 125 */ + volatile u_int32_t nicMacRxBufDescrAttns; /* 126 */ + volatile u_int32_t nicMacRxBufAttns; /* 127 */ + volatile u_int32_t nicMacRxZeroFrameCleanup; /* 128 */ + volatile u_int32_t nicMacRxOneFrameCleanup; /* 129 */ + volatile u_int32_t nicMacRxMultipleFrameCleanup; /* 130 */ + volatile u_int32_t nicMacRxTimerCleanup; /* 131 */ + volatile u_int32_t nicMacRxDmaCleanup; /* 132 */ + /* + * Stats from the mac_stats area + */ + volatile u_int32_t nicMacTxCollisionHistogram[15]; /* 133 */ + /* + * MAC TX Attentions + */ + volatile u_int32_t nicMacTxTotalAttns; /* 134 */ + /* + * NIC Profile + */ + volatile u_int32_t nicProfile[32]; /* 135 */ + /* + * Pat to 1024 bytes. + */ + u_int32_t pad[75]; +}; + +struct tg_reg { + u_int32_t data; + u_int32_t addr; +}; + +struct tg_mem { + u_int32_t tgAddr; + caddr_t userAddr; + int len; +}; + + +typedef enum { + TI_PARAM_NONE = 0x00, + TI_PARAM_STAT_TICKS = 0x01, + TI_PARAM_RX_COAL_TICKS = 0x02, + TI_PARAM_TX_COAL_TICKS = 0x04, + TI_PARAM_RX_COAL_BDS = 0x08, + TI_PARAM_TX_COAL_BDS = 0x10, + TI_PARAM_TX_BUF_RATIO = 0x20, + TI_PARAM_ALL = 0x2f +} ti_param_mask; + +struct ti_params { + u_int32_t ti_stat_ticks; + u_int32_t ti_rx_coal_ticks; + u_int32_t ti_tx_coal_ticks; + u_int32_t ti_rx_max_coal_bds; + u_int32_t ti_tx_max_coal_bds; + u_int32_t ti_tx_buf_ratio; + ti_param_mask param_mask; +}; + +typedef enum { + TI_TRACE_TYPE_NONE = 0x00000000, + TI_TRACE_TYPE_SEND = 0x00000001, + TI_TRACE_TYPE_RECV = 0x00000002, + TI_TRACE_TYPE_DMA = 0x00000004, + TI_TRACE_TYPE_EVENT = 0x00000008, + TI_TRACE_TYPE_COMMAND = 0x00000010, + TI_TRACE_TYPE_MAC = 0x00000020, + TI_TRACE_TYPE_STATS = 0x00000040, + TI_TRACE_TYPE_TIMER = 0x00000080, + TI_TRACE_TYPE_DISP = 0x00000100, + TI_TRACE_TYPE_MAILBOX = 0x00000200, + TI_TRACE_TYPE_RECV_BD = 0x00000400, + TI_TRACE_TYPE_LNK_PHY = 0x00000800, + TI_TRACE_TYPE_LNK_NEG = 0x00001000, + TI_TRACE_LEVEL_1 = 0x10000000, + TI_TRACE_LEVEL_2 = 0x20000000 +} ti_trace_type; + +struct ti_trace_buf { + u_long *buf; + int buf_len; + int fill_len; + u_long cur_trace_ptr; +}; + +#define TIIOCGETSTATS _IOR('T', 1, struct ti_stats) +#define TIIOCGETPARAMS _IOR('T', 2, struct ti_params) +#define TIIOCSETPARAMS _IOW('T', 3, struct ti_params) +#define TIIOCSETTRACE _IOW('T', 11, ti_trace_type) +#define TIIOCGETTRACE _IOWR('T', 12, struct ti_trace_buf) + +/* + * Taken from Alteon's altioctl.h. Alteon's ioctl numbers 1-6 aren't + * used by the FreeBSD driver. + */ +#define ALT_ATTACH _IO('a', 7) +#define ALT_READ_TG_MEM _IOWR('a', 10, struct tg_mem) +#define ALT_WRITE_TG_MEM _IOWR('a', 11, struct tg_mem) +#define ALT_READ_TG_REG _IOWR('a', 12, struct tg_reg) +#define ALT_WRITE_TG_REG _IOWR('a', 13, struct tg_reg) + +#endif /* _SYS_TIIO_H_ */